This typically happens on Suns and other systems that use shared
libraries. The cause is that the site has installed a version of the
shared library which uses a name server--but has not installed a
-similiar version of the unshared library which Emacs uses.
+similar version of the unshared library which Emacs uses.
The result is that most programs, using the shared library, work with
the nameserver, but Emacs does not.
* Trouble using ptys on AIX.
-People often instll the pty devices on AIX incorrectly.
+People often install the pty devices on AIX incorrectly.
Use `smit pty' to reinstall them properly.
* Shell mode on HP/UX gives the message, "`tty`: Ambiguous".
to map two other input characters (such as C-^ and C-\) into C-s and
C-q, so that you can still search and quote.
-I have no intention of ever redisigning the Emacs command set for
+I have no intention of ever redesigning the Emacs command set for
the assumption that terminals use C-s/C-q flow control. This
flow control technique is a bad design, and terminals that need
it are bad merchandise and should not be purchased. If you can
inst_paths='#disabled# '
;;
- ## Has the user specifiec an installation prefix?
+ ## Has the user specified an installation prefix?
"prefix" )
## If the value was omitted, get it from the next argument.
if [ "${valomitted}" = "yes" ]; then
prefix="${val}"
;;
- ## Has the user specifiec an installation prefix?
+ ## Has the user specified an installation prefix?
"exec_prefix" )
## If the value was omitted, get it from the next argument.
if [ "${valomitted}" = "yes" ]; then
The real legal meaning of the GNU General Public Licence (copyleft) is
however it is interpreted by a judge. There has never been a copyright
- infringment case involving the GPL to set any precedents. Please take any
+ infringement case involving the GPL to set any precedents. Please take any
discussion regarding this issue to the newsgroup gnu.misc.discuss, which
was created to hold the extensive flame wars on the subject.
If you are receiving a GNU mailing list named `XXX', you might be able
to unsubscribe to it by sending a request to the address
`XXX-request@prep.ai.mit.edu'. However, this will not work if you are
- not listed on the main mailing list, but instead recieve the mail from a
+ not listed on the main mailing list, but instead receive the mail from a
distribution point. In that case, you will have to track down at which
distribution point you are listed. Inspecting the `Received:' headers
on the mail messages may help, along with liberal use of the `EXPN' or
Cliff Stoll in his book `The Cuckoo's Egg' describes this in chapter 4.
The site at LBL had installed the `etc/movemail' program setuid root.
Since `movemail' had not been designed for this situation, a security
- hole was created and users could get root priveleges.
+ hole was created and users could get root privileges.
`movemail' has since been changed so that even if it is installed setuid
root this security hole will not be a result.
Emacs accepts synthetic X events generated by the SendEvent request as
though they were regular events. As a result, if you are using the
trivial host-based authentication, other users who can open X
- connections to your X workstatation can make your Emacs process do
- anything, including run other processes with your priveleges.
+ connections to your X workstation can make your Emacs process do
+ anything, including run other processes with your privileges.
The only fix for this is to prevent other users from being able to open
X connections. The standard way to prevent this is to use a real
;; LCD Archive Entry:
;; tex-complete|Sebastian Kremer|sk@thp.Uni-Koeln.DE
;; |Minibuffer name completion for editing [La]TeX.
- ;; |91-03-26|$Revision: 20.5 $|~/packages/tex-complete.el.Z !
+ ;; |91-03-26|$Revision: 1.4 $|~/packages/tex-complete.el.Z !
Dave Brennan has software which automatically looks for data in this
format. The format is fairly flexible. The entry ends when a line is
X keysyms Up, Left, Right, and Down.)
Break (the `Alternate' key is given this keysym)
- These keys work like Sun function keys. When Emacs recieves the
+ These keys work like Sun function keys. When Emacs receives the
keysym, it will internally use character sequences that look like "ESC
[ ### z", where ### is replaced by a number. The character sequences
are identical to those generated by Sun's keyboard under SunView. Any
With these patches, Emacs becomes fully 8-bit operational. There is
support for displaying 8-bit characters, as well as for entering such
- characters from the keyboard. In addition, upcase/lowcase tranlatsion
+ characters from the keyboard. In addition, upcase/lowcase translation
is supported, accented characters are recognized as "letters" (important
when doing 'forward-word', for example), and text with 8-bit characters
can be sorted correctly.
# Briefly, the settings are for the following modes:
# (values are for bit set/clear with * indicating our preference
# and the value used to test these termcaps)
-# Note that many of these settings are irelevent to the termcap
+# Note that many of these settings are irrelevant to the termcap
# and are just set to the default mode of the terminal as shipped
# by the factory.
#
# transmit all characters/transmit only selected characters*
# transmit all selected areas/transmit only 1 selected area*
#
-# transmit/do not transmit line seperators to host*
+# transmit/do not transmit line separators to host*
# transmit/do not transmit page tab stops tabs to host*
# transmit/do not transmit column tab stop tabs to host*
# transmit/do not transmit graphics control (underline,inverse..)*
#
# D menu: 0110 1001 1 0
# LF is newline/LF is down one line, same column*
-# wrap to preceeding line if move left from col 1*/don't wrap
+# wrap to preceding line if move left from col 1*/don't wrap
# wrap to next line if move right from col 80*/don't wrap
# backspace is/is not destructive*
#
:kl=^H:ku=^K:kr=^L:kd=^J:tc=adm3a:
# Needs function keys added. Also can't use 60 line mode because it needs
# too much nl delay - can fix for nl but not out of vi.
-# The cl delay is sufficent, but a smaller one could do.
+# The cl delay is sufficient, but a smaller one could do.
# This entry is merged from Mike O'Brien@Rand and Howard Katseff at
# Bell Labs, and is untested.
Mb|aaa|ambas|ambassador|ann arbor ambassador/48 lines:\
^([a-z]\ -)?\ *{EC}: {
/*
- * error message (which we print immediately) preceeded by an
+ * error message (which we print immediately) preceded by an
* error code (which we ignore)
*/
/* define WANT_CAPS_LOCK to make f-key T1 (aka F1) behave as CapsLock */
#define WANT_CAPS_LOCK
#ifdef WANT_CAPS_LOCK
-int caps_lock; /* toggle indicater for f-key T1 caps lock */
+int caps_lock; /* toggle indicator for f-key T1 caps lock */
static char *Caps = "[CAPS] "; /* Caps Lock prefix string */
#define CAPS_LEN 7 /* strlen (Caps) */
#endif
}
/*
- * This routine sets up the boolean psuedo-functions which work
+ * This routine sets up the boolean pseudo-functions which work
* by setting boolean flags dependent upon the corresponding character
* Every char which is NOT in that string is not a white char. Therefore,
* all of the array "_wht" is set to FALSE, and then the elements
register char *pend;
int newline; /* 1 if ended with newline, 0 if ended with EOF */
- pend = p + linebuffer->size; /* Separate to avoind 386/IX compiler bug. */
+ pend = p + linebuffer->size; /* Separate to avoid 386/IX compiler bug. */
while (1)
{
starting in column zero.
(quote NAME) may appear as 'NAME as well.
For defun, defmacro, and autoload, we know how to skip over the arglist.
- For defvar, defconst, and fset we skip to the docstring with a klugey
+ For defvar, defconst, and fset we skip to the docstring with a kludgy
formatting convention: all docstrings must appear on the same line as the
initial open-paren (the one in column zero) and must contain a backslash
and a double-quote immediately after the initial double-quote. No newlines
char *pname; /* programme name for error messages */
-/* Accepts a string of two fields seperated by FS.
+/* Accepts a string of two fields separated by FS.
First field is string for get_date, saying when to wake-up.
Second field is a token to identify the request. */
void
}
/* Read until SEP, read next line, print it.
- (Note that we will never print anything before the first seperator.)
+ (Note that we will never print anything before the first separator.)
If we hit EOF looking for the first SEP, just recurse. */
while ((c = getc(fp)) != SEP)
if (c == EOF) {
;;;###autoload
(defun change-log-mode ()
- "Major mode for editting change logs; like Indented Text Mode.
+ "Major mode for editing change logs; like Indented Text Mode.
Prevents numeric backups and sets `left-margin' to 8 and `fill-column' to 74.
New log entries are usually made with \\[add-change-log-entry] or \\[add-change-log-entry-other-window].
Each entry behaves as a paragraph, and the entries for one day as a page.
;;;_ - Author: Ken Manheimer <klm@nist.gov>
;;;_ - Maintainer: Ken Manheimer <klm@nist.gov>
;;;_ - Created: Dec 1991 - first release to usenet
-;;;_ - Version: $Id: allout.el,v 1.1 1993/06/02 17:53:31 rms Exp rms $||
+;;;_ - Version: $Id: allout.el,v 1.2 1993/06/07 18:48:08 rms Exp jimb $||
;;;_ - Keywords: outline mode
;;;_ - LCD Archive Entry
;; LCD Archive Entry:
;; allout|Ken Manheimer|klm@nist.gov
;; |A more thorough outline-mode
-;; |27-May-1993|$Id: allout.el,v 1.1 1993/06/02 17:53:31 rms Exp rms $||
+;; |27-May-1993|$Id: allout.el,v 1.2 1993/06/07 18:48:08 rms Exp jimb $||
;;;_ - Description
;; A full-fledged outline mode, based on the original rudimentary
;;;_ = outline-primary-bullet
(defvar outline-primary-bullet "*") ;; Changing this var disables any
- ;; backwards compatability with
+ ;; backwards compatibility with
;; the original outline mode.
(make-variable-buffer-local 'outline-primary-bullet)
;;;_ : Key bindings
;;;_ = Generic minor keybindings control
-;;;_ ; Stallmans suggestion
+;;;_ ; Stallman's suggestion
(defvar outline-mode-map nil "")
(if outline-mode-map
Exposure: Hidden (~closed~) topics are represented by ellipses ('...')
at the end of the visible SUPERTOPIC which contains them,
rather than by their actual text. Hidden topics are still
- susceptable to editing and regular movement functions, they
+ susceptible to editing and regular movement functions, they
just are not displayed normally, effectively collapsed into
the ellipses which represent them. Outline mode provides
the means to selectively expose topics based on their
topic header PREFIX at the beginning of the line, followed by
text to the end of the EFFECTIVE LINE.
-Body: Any subsequent lines of text following a topic header and preceeding
+Body: Any subsequent lines of text following a topic header and preceding
the next one. This is also referred to as the entry for a topic.
Prefix: The text which distinguishes topic headers from normal text
by zero or more spaces and then an outline BULLET. [Note - you
can now designate your own, arbitrary HEADER-LEAD string, by
setting the variable 'outline-header-prefix'.] The second form
- is for backwards compatability with the original emacs outline
+ is for backwards compatibility with the original emacs outline
mode, and consists solely of asterisks. Both sorts are
recognized by all outline commands. The first sort is generated
by outline topic production commands if the emacs variable
that the index for the numbered prefix will be derived, by counting
siblings back to start of level. If INDEX is a number, then that
number is used as the index for the numbered prefix (allowing, eg,
- sequential renumbering to not requre this function counting back the
+ sequential renumbering to not require this function counting back the
index for each successive sibling)."
;; The options are ordered in likely frequence of use, most common
- Creation of sibling or nested topics is with respect to the topic
you're starting from, even when creating backwards. This way you
can easily create a sibling in front of the current topic without
- having to go to it's preceeding sibling, and then open forward
+ having to go to its preceding sibling, and then open forward
from there."
(let* ((depth (+ (outline-current-depth) relative-depth))
(or (and (not (> relative-depth 0))
;; not descending,
(save-excursion
- ;; preceeded by a blank line?
+ ;; preceded by a blank line?
(forward-line -1)
(looking-at "^\\s-*$")))
(and (= ref-depth 1)
" Reindent body lines which were indented at old-depth to new-depth.
Note that refill of indented paragraphs is not done, and tabs are
- not accomodated. ('untabify' your outline if you want to preserve
+ not accommodated. ('untabify' your outline if you want to preserve
hanging body indents.)"
(save-excursion
(yank arg)
(exchange-dot-and-mark)
(if (and established-depth ; the established stuff qualifies.
- ;; The yanked stuff also qualfies - is topic(s):
+ ;; The yanked stuff also qualifies - is topic(s):
(looking-at (concat "\\(" outline-regexp "\\)")))
;; Ok, adjust the depth of the yanked stuff. Note that the
;; stuff may have more than a single root, so we have to
)
)
)
-;;;_ > outline-to-entry-end - Unmaintained compatability - ignore this!
+;;;_ > outline-to-entry-end - Unmaintained compatibility - ignore this!
;-------------------------------------------------------------------
; Something added solely for use by a "smart menu" package someone got
; off the net. I have no idea whether this is appropriate code.
(if arg (insert-string (format "\t\t\t(%s \"%s\")\n"
"outline-lead-with-comment-string"
arg)))
- ; Insert ammouncement and
+ ; Insert announcement and
; exposure control:
(insert-string
(format "\t\t\t%s %s\n\t\t\t%s %s\n\t\t%s %s"
;;; Gateways:
;;;
-;;; Sometimes it is neccessary for the FTP process to be run on a different
+;;; Sometimes it is necessary for the FTP process to be run on a different
;;; machine than the machine running GNU Emacs. This can happen when the
;;; local machine has restrictions on what hosts it can access.
;;;
;;;
;;; 3) Using NFS and symlinks, make sure that there is a shared directory with
;;; the *same* name between the local machine and the gateway machine.
-;;; This directory is neccessary for temporary files created by ange-ftp.
+;;; This directory is necessary for temporary files created by ange-ftp.
;;;
;;; 4) Set the variable 'ange-ftp-gateway-tmp-name-template' to the name of
;;; this directory plus an identifying filename prefix. For example:
;;; there is a chance you might connect to an ULTRIX machine (such as
;;; prep.ai.mit.edu), then set this variable accordingly. This will have
;;; the side effect that dired will have problems with symlinks whose names
-;;; end in an @. If you get youself into this situation then editing
+;;; end in an @. If you get yourself into this situation then editing
;;; dired's ls-switches to remove "F", will temporarily fix things.
;;;
;;; 2. If you know that you are connecting to a certain non-UNIX machine
;;; 1. Umask problems:
;;; Be warned that files created by using ange-ftp will take account of the
;;; umask of the ftp daemon process rather than the umask of the creating
-;;; user. This is particulary important when logging in as the root user.
+;;; user. This is particularly important when logging in as the root user.
;;; The way that I tighten up the ftp daemon's umask under HP-UX is to make
;;; sure that the umask is changed to 027 before I spawn /etc/inetd. I
;;; suspect that there is something similar on other systems.
;;;; Internal variables.
;;;; ------------------------------------------------------------
-(defconst ange-ftp-version "$Revision: 1.23 $")
+(defconst ange-ftp-version "$Revision: 1.24 $")
(defvar ange-ftp-data-buffer-name " *ftp data*"
"Buffer name to hold directory listing data received from ftp process.")
"Return the password for specified HOST and USER, asking user if necessary."
(ange-ftp-parse-netrc)
- ;; look up password in the hash table first; user might have overriden the
+ ;; look up password in the hash table first; user might have overridden the
;; defaults.
(cond ((ange-ftp-lookup-passwd host user))
;;;; ------------------------------------------------------------
(defun ange-ftp-process-handle-line (line proc)
- "Look at the given LINE from the ftp process PROC. Try to catagorize it
+ "Look at the given LINE from the ftp process PROC. Try to categorize it
into one of four categories: good, skip, fatal, or unknown."
(cond ((string-match ange-ftp-xfer-size-msgs line)
(setq ange-ftp-xfer-size
;; (kill-buffer (current-buffer))))))
;; this is the extended version of ange-ftp-copy-file-internal that works
-;; asyncronously if asked nicely.
+;; asynchronously if asked nicely.
(defun ange-ftp-copy-file-internal (filename newname ok-if-already-exists
keep-date &optional msg cont nowait)
(setq filename (expand-file-name filename)
;; 0 ;success-count
;; (length fn-list) ;total
;; )
-;; ;; normal case... use the interative routine... much cheaper.
+;; ;; normal case... use the interactive routine... much cheaper.
;; (ange-ftp-real-dired-create-files file-creator operation fn-list
;; name-constructor marker-char)))
;;; Commentary:
;; Edit, delete, or change attributes of all currently active Emacs
-;; buffers from a list summarizing thir state. A good way to browse
+;; buffers from a list summarizing their state. A good way to browse
;; any special or scratch buffers you have loaded, since you can't find
;; them by filename. The single entry point is `Buffer-menu-mode',
;; normally bound to C-x C-b.
;; calendar, to the Islamic calendar, to the French Revolutionary calendar,
;; to the Mayan calendar, and to the astronomical (Julian) day number.
;; When floating point is available, times of sunrise/sunset can be displayed,
-;; as can the phases of the moon. Appointment notication for diary entries
+;; as can the phases of the moon. Appointment notification for diary entries
;; is available.
;; The following files are part of the calendar/diary code:
(monthname " *" day ", *" year "[^0-9]")
(dayname "\\W"))
"*List of pseudo-patterns describing the American patterns of date used.
-See the documentation of diary-date-forms for an explanantion.")
+See the documentation of diary-date-forms for an explanation.")
;;;###autoload
(defvar european-date-diary-pattern
(day " *" monthname " *" year "[^0-9]")
(dayname "\\W"))
"*List of pseudo-patterns describing the European patterns of date used.
-See the documentation of diary-date-forms for an explanantion.")
+See the documentation of diary-date-forms for an explanation.")
;;;###autoload
(defvar diary-date-forms
'((if dayname (concat dayname ", ")) day " " monthname " " year)
"*The pseudo-pattern that governs the way a Gregorian date is formatted
in the European style. See the documentation of calendar-date-display-forms
-for an explanantion.")
+for an explanation.")
;;;###autoload
(defvar american-calendar-display-form
'((if dayname (concat dayname ", ")) monthname " " day ", " year)
"*The pseudo-pattern that governs the way a Gregorian date is formatted
in the American style. See the documentation of calendar-date-display-forms
-for an explanantion.")
+for an explanation.")
;;;###autoload
(defvar calendar-date-display-form
To include a holiday conditionally, use the if or the sexp form. For example,
to include American presidential elections, which occur on the first Tuesday
-after the first Monday in November of years divisble by 4, add
+after the first Monday in November of years divisible by 4, add
(sexp (if (zerop (% year 4))
(calendar-gregorian-from-absolute
\\[calendar-print-french-date] show equivalent date on the French Revolutionary calendar
\\[calendar-print-mayan-date] show equivalent date on the Mayan calendar
-The astromonical (Julian) day number of a date is found with
+The astronomical (Julian) day number of a date is found with
\\[calendar-print-astro-day-number] show equivalent astronomical (Julian) day number
"Move cursor to astronomical (Julian) DAYNUMBER.
Echo astronomical (Julian) day number unless NOECHO is t."
(interactive (list (calendar-read
- "Astromonical (Julian) day number (>1721425): "
+ "Astronomical (Julian) day number (>1721425): "
'(lambda (x) (> x 1721425)))))
(calendar-goto-date (calendar-gregorian-from-absolute (- daynumber 1721425)))
(or noecho (calendar-print-astro-day-number)))
;;; Commentary:
;; This collection of functions implements the features of calendar.el and
-;; diary.el that deal with sunrise/sunset and eqinoxes/solstices.
+;; diary.el that deal with sunrise/sunset and equinoxes/solstices.
;; Based on the ``Almanac for Computers 1984,'' prepared by the Nautical
;; Almanac Office, United States Naval Observatory, Washington, 1984 and
;;; extract a value with (extract-from-klist KLIST KEY [DEFAULT]).
(defun reduce (function sequence &rest kargs)
- "Apply FUNCTION (a function of two arguments) to succesive pairs of elements
+ "Apply FUNCTION (a function of two arguments) to successive pairs of elements
from SEQUENCE. Some keyword arguments are valid after FUNCTION and SEQUENCE:
:from-end If non-nil, process the values backwards
:initial-value If given, prefix it to the SEQUENCE. Suffix, if :from-end
(do* ((absa (abs (nth 0 integers))) ; better to operate only
(absb (abs (nth 1 integers))) ;on positives.
(dd (max absa absb)) ; setup correct order for the
- (ds (min absa absb)) ;succesive divisions.
+ (ds (min absa absb)) ;successive divisions.
;; intermediate results
(q 0)
(r 0)
(defsetf apply
(lambda (&rest args)
- ;; dissasemble the calling form
+ ;; disassemble the calling form
;; "(((quote fn) x1 x2 ... xn) val)" (function instead of quote, too)
(let* ((fnform (car args)) ;functional form
(applyargs (append ;arguments "to apply fnform"
list \{:conc-name, :copier, :constructor, :predicate, :include,
:print-function, :type, :initial-offset\}. The meanings of these are as in
CLtL, except that no BOA-constructors are provided, and the options
-\{:print-fuction, :type, :initial-offset\} are ignored quietly. All these
+\{:print-function, :type, :initial-offset\} are ignored quietly. All these
structs are named, in the sense that their names can be used for type
discrimination.
do the right thing. If you run multiple processes, you can change
cmulisp-buffer to another process buffer with \\[set-variable].
-More sophisticated approaches are, of course, possible. If you find youself
+More sophisticated approaches are, of course, possible. If you find yourself
needing to switch back and forth between multiple processes frequently,
you may wish to consider ilisp.el, a larger, more sophisticated package
for running inferior Lisp processes. The approach taken here is for a
do the right thing. If you run multiple processes, you can change
scheme-buffer to another process buffer with \\[set-variable].
-More sophisticated approaches are, of course, possible. If you find youself
+More sophisticated approaches are, of course, possible. If you find yourself
needing to switch back and forth between multiple processes frequently,
you may wish to consider ilisp.el, a larger, more sophisticated package
for running inferior Lisp and Scheme processes. The approach taken here is
;;; 9/5/90 shivers
;;; - Changed make-variable-buffer-local's to make-local-variable's.
;;; This leaves non-comint-mode buffers alone. Stephane Payrard
-;;; reported the sloppy useage.
+;;; reported the sloppy usage.
;;; - You can now go from comint-previous-similar-input to
;;; comint-previous-input with no problem.
;;;
;;;---------------------
;;;
;;; A "word" is any string containing characters with either word or symbol
-;;; syntax. [E.G. Any alphanumeric string with hypens, underscores, etc.]
+;;; syntax. [E.G. Any alphanumeric string with hyphens, underscores, etc.]
;;; Unless you change the constants, you must type at least three characters
;;; for the word to be recognized. Only words longer than 6 characters are
;;; saved.
;;;
;;; When you load this file, completion will be on. I suggest you use the
-;;; compiled version (because it is noticibly faster).
+;;; compiled version (because it is noticeably faster).
;;;
;;; M-X completion-mode toggles whether or not new words are added to the
;;; database by changing the value of enable-completion.
;;; superior to that of the LISPM version.
;;;
;;;-----------------------------------------------
-;;; Acknowlegements
+;;; Acknowledgements
;;;-----------------------------------------------
;;; Cliff Lasser (cal@think.com), Kevin Herbert (kph@cisco.com),
;;; eero@media-lab, kgk@cs.brown.edu, jla@ai.mit.edu,
;;;
;;; C diffs ->
;;; Separator chars :: + * / : %
-;;; A note on the hypen (`-'). Perhaps, the hypen should also be a separator
+;;; A note on the hyphen (`-'). Perhaps the hyphen should also be a separator
;;; char., however, we wanted to have completion symbols include pointer
;;; references. For example, "foo->bar" is a symbol as far as completion is
;;; concerned.
(defconst cmpl-obarray-length 511)
(defvar cmpl-prefix-obarray (make-vector cmpl-obarray-length 0)
- "An obarray used to store the downcased completion prefices.
+ "An obarray used to store the downcased completion prefixes.
Each symbol is bound to a list of completion entries.")
(defvar cmpl-obarray (make-vector cmpl-obarray-length 0)
(defmacro set-cmpl-prefix-entry-tail (prefix-entry new-tail)
(list 'setcdr prefix-entry new-tail))
-;;; Contructor
+;;; Constructor
(defun make-cmpl-prefix-entry (completion-entry-list)
"Makes a new prefix entry containing only completion-entry."
;;; WRITES
(defun add-completion-to-tail-if-new (string)
"If STRING is not in the database add it to appropriate prefix list.
-STRING is added to the end of the approppriate prefix list with
+STRING is added to the end of the appropriate prefix list with
num-uses = 0. The database is unchanged if it is there. STRING must be
longer than `completion-prefix-min-length'.
This must be very fast.
(defun add-completion-to-head (string)
"If STRING is not in the database, add it to prefix list.
-STRING is added to the head of the approppriate prefix list. Otherwise
+STRING is added to the head of the appropriate prefix list. Otherwise
it is moved to the head of the list.
STRING must be longer than `completion-prefix-min-length'.
Updates the saved string with the supplied string.
(defun complete (&optional arg)
"Fill out a completion of the word before point.
-Point is left at end. Consective calls rotate through all possibilities.
+Point is left at end. Consecutive calls rotate through all possibilities.
Prefix args ::
control-u :: leave the point at the beginning of the completion rather
than at the end.
;;; Symbol separator chars (have whitespace syntax) --> , ; * = (
;;; Opening char --> [ {
;;; Closing char --> ] }
-;;; openning and closing must be skipped over
+;;; opening and closing must be skipped over
;;; Whitespace chars (have symbol syntax)
;;; Everything else has word syntax
(defun cmpl-make-c-def-completion-syntax-table ()
(let ((table (make-vector 256 0))
(whitespace-chars '(? ?\n ?\t ?\f ?\v ?\r))
- ;; unforunately the ?( causes the parens to appear unbalanced
+ ;; unfortunately the ?( causes the parens to appear unbalanced
(separator-chars '(?, ?* ?= ?\( ?\;
))
)
;;; Patches to self-insert-command.
;;;-----------------------------------------------
-;;; Need 2 versions: generic seperator chars. and space (to get auto fill
+;;; Need 2 versions: generic separator chars. and space (to get auto fill
;;; to work)
;;; All common separators (eg. space "(" ")" """) characters go through a
;;; function to add new words to the list of words to complete from:
;;; COMPLETION-SEPARATOR-SELF-INSERT-COMMAND (arg).
;;; If the character before this was an alpha-numeric then this adds the
-;;; symbol befoe point to the completion list (using ADD-COMPLETION).
+;;; symbol before point to the completion list (using ADD-COMPLETION).
(defun completion-separator-self-insert-command (arg)
(interactive "p")
(defun dired-shell-quote (filename)
"Quote a file name for inferior shell (see variable `shell-file-name')."
;; Quote everything except POSIX filename characters.
- ;; This should be safe enough even for really wierd shells.
+ ;; This should be safe enough even for really weird shells.
(let ((result "") (start 0) end)
(while (string-match "[^---0-9a-zA-Z_./]" filename start)
(setq end (match-beginning 0)
(defun dired-compress-file (file)
;; Compress or uncompress FILE.
;; Return the name of the compressed or uncompressed file.
- ;; Rerurn nil if no change in files.
+ ;; Return nil if no change in files.
(let ((handler (find-file-name-handler file)))
(cond (handler
(funcall handler 'dired-compress-file file))
nil))
(if reason ; don't move away on failure
(goto-char opoint))
- (not reason))) ; return t on succes, nil else
+ (not reason))) ; return t on success, nil else
;; This is a separate function for the sake of nested dired format.
(defun dired-add-entry-do-indentation (marker-char)
;; the new files. Target may be a plain file if only one marked
;; file exists.
;; OP-SYMBOL is the symbol for the operation. Function `dired-mark-pop-up'
- ;; will determine wether pop-ups are appropriate for this OP-SYMBOL.
+ ;; will determine whether pop-ups are appropriate for this OP-SYMBOL.
;; FILE-CREATOR and OPERATION as in dired-create-files.
;; ARG as in dired-get-marked-files.
;; Optional arg OP1 is an alternate form for OPERATION if there is
(defvar dired-chown-program
(if (memq system-type '(hpux dgux usg-unix-v silicon-graphics-unix))
"chown" "/etc/chown")
- "Name of chown command (usully `chown' or `/etc/chown').")
+ "Name of chown command (usually `chown' or `/etc/chown').")
;;;###autoload
(defvar dired-ls-F-marks-symlinks nil
(dired-sort-other dired-actual-switches t)
(run-hooks 'dired-mode-hook))
\f
-;; Ideosyncratic dired commands that don't deal with marks.
+;; Idiosyncratic dired commands that don't deal with marks.
(defun dired-quit ()
"Bury the current dired buffer."
;;; Commentary:
- ;;; This is a rudimentry backquote package written by D. King,
+ ;;; This is a rudimentary backquote package written by D. King,
;;; king@kestrel, on 8/31/85. (` x) is a macro
;;; that expands to a form that produces x. (` (a b ..)) is
;;; a macro that expands into a form that produces a list of what a b
;;; These two advertised variables control what characters are used to
;;; unquote things. I have included , and ,@ as the unquote and
;;; splice operators, respectively, to give users of MIT CADR machine
- ;;; derivitive machines a warm, cosy feeling.
+ ;;; derivative machines a warm, cosy feeling.
(defconst backquote-unquote '(,)
"*A list of all objects that stimulate unquoting in `. Memq test.")
;;; Given a state/tailmaker pair that already knows how to make a
;;; partial tail of the desired form, this function knows how to add
- ;;; yet another element to the burgening list. There are four cases;
+ ;;; yet another element to the burgeoning list. There are four cases;
;;; the next item is an atom (which will certainly be quoted); a
;;; (, xxx), which will be evaluated and put into the list at the top
;;; level; a (,@ xxx), which will be evaluated and spliced in, or
((memq fn '(and or)) ; remember, and/or are control structures.
;; take forms off the back until we can't any more.
- ;; In the future it could concievably be a problem that the
+ ;; In the future it could conceivably be a problem that the
;; subexpressions of these forms are optimized in the reverse
;; order, but it's ok for now.
(if for-effect
;;;
;;; It is now safe to optimize code such that it introduces new bindings.
-;; I'd like this to be a defsubst, but let's not be self-referental...
+;; I'd like this to be a defsubst, but let's not be self-referential...
(defmacro byte-compile-trueconstp (form)
;; Returns non-nil if FORM is a non-nil constant.
(` (cond ((consp (, form)) (eq (car (, form)) 'quote))
;; I'm not convinced that this is necessary. Doesn't the optimizer loop
;; take care of this? - Jamie
;; I think this may some times be necessary to reduce ie (quote 5) to 5,
-;; so arithmetic optimizers recognize the numerinc constant. - Hallvard
+;; so arithmetic optimizers recognize the numeric constant. - Hallvard
(put 'quote 'byte-optimizer 'byte-optimize-quote)
(defun byte-optimize-quote (form)
(if (or (consp (nth 1 form))
;;; and by the disassembler.
;;;
(defun byte-decompile-bytecode (bytes constvec)
- "Turns BYTECODE into lapcode, refering to CONSTVEC."
+ "Turns BYTECODE into lapcode, referring to CONSTVEC."
(let ((byte-compile-constants nil)
(byte-compile-variables nil)
(byte-compile-tag-number 0))
((and (eq (car lap0) 'TAG)
(eq (car lap1) 'TAG))
(and (memq byte-optimize-log '(t byte))
- (byte-compile-log " adjascent tags %d and %d merged"
+ (byte-compile-log " adjacent tags %d and %d merged"
(nth 1 lap1) (nth 1 lap0)))
(setq tmp3 lap)
(while (setq tmp2 (rassq lap0 tmp3))
;;;
;;; o The form `eval-when-compile' is like progn, except that the body
;;; is evaluated at compile-time. When it appears at top-level, this
-;;; is analagous to the Common Lisp idiom (eval-when (compile) ...).
+;;; is analogous to the Common Lisp idiom (eval-when (compile) ...).
;;; When it does not appear at top-level, it is similar to the
;;; Common Lisp #. reader macro (but not in interpreted code.)
;;;
(byte-defop 24 -1 byte-varbind "for binding a variable")
(byte-defop 32 0 byte-call "for calling a function")
(byte-defop 40 0 byte-unbind "for unbinding special bindings")
-;; codes 8-47 are consumed by the preceeding opcodes
+;; codes 8-47 are consumed by the preceding opcodes
;; unused: 48-55
(defun byte-compile-associative (form)
(if (cdr form)
(let ((opcode (get (car form) 'byte-opcode)))
- ;; To compile all the args first may enable some optimizaions.
+ ;; To compile all the args first may enable some optimizations.
(mapcar 'byte-compile-form (setq form (cdr form)))
(while (setq form (cdr form))
(byte-compile-out opcode 0)))
(defun byte-compile-funarg (form)
;; (mapcar '(lambda (x) ..) ..) ==> (mapcar (function (lambda (x) ..)) ..)
- ;; for cases where it's guarenteed that first arg will be used as a lambda.
+ ;; for cases where it's guaranteed that first arg will be used as a lambda.
(byte-compile-normal-call
(let ((fn (nth 1 form)))
(if (and (eq (car-safe fn) 'quote)
;; which does special things with subforms.
(let ((depth 0)
;; Path describes the position of point in terms of
- ;; list-structure with respect to contining lists.
+ ;; list-structure with respect to containing lists.
;; `foo' has a path of (0 4 1) in `((a b c (d foo) f) g)'
(path ())
;; set non-nil when somebody works out the indentation to use
path state indent-point sexp-column normal-indent))
(funcall (function lisp-indent-259)
'((&whole nil &rest
- ;; the following causes wierd indentation
+ ;; the following causes weird indentation
;;(&whole 1 1 2 nil)
)
(&whole nil &rest 1))
`print-length' and `print-level'.
If non-nil, shared substructures anywhere in the structure are printed
-with `#N=' before the first occurance (in the order of the print
-representation) and `#N#' in place of each subsequent occurance,
+with `#N=' before the first occurrence (in the order of the print
+representation) and `#N#' in place of each subsequent occurrence,
where N is a positive decimal integer.
Currently, there is no way to read this representation in Emacs.")
(defun custom-message (fmt &rest args)
"Replacement for standard `message' that works like `custom-format'."
- ;; It doesnt work to princ the result of custom-format
+ ;; It doesn't work to princ the result of custom-format
;; because the echo area requires special handling
;; to avoid duplicating the output. cust-print-internal-message does it right.
;; (cust-print-internal-princ (apply 'custom-format fmt args))
;; Print the custom OBJECT using the custom type ALIST.
;; For the first predicate that matches the object, the corresponding
;; converter is evaluated with the object and the string that results is
-;; printed with princ. Return nil if no predicte matches the object.
+;; printed with princ. Return nil if no predicate matches the object.
(defun cust-print-custom-object1 (object alist)
(while (and alist (not (funcall (car (car alist)) object)))
(setq alist (cdr alist)))
;;; Reset edebug-mode only on
;;; first entry of any function at each recursive-edit level.
;;; Add edebug-backtrace, to generate cleaned up
-;;; backtrace. It doesnt "work" like the debug backtrace, however.
+;;; backtrace. It doesn't "work" like the debug backtrace, however.
;;; Require reselecting outside window even if
;;; quit occurs, otherwise save-excursions may restore
;;; buffer to the wrong window.
;;; Leave point at syntax error, mark at starting position.
;;;
;;; Revision 1.2 88/11/28 12:14:15 liberte
-;;; Bug fixes: cond construct didnt execute.
-;;; () in sexp list didnt parse
-;;; () as variable in condition-case didnt parse.
+;;; Bug fixes: cond construct didn't execute.
+;;; () in sexp list didn't parse
+;;; () as variable in condition-case didn't parse.
;;;
;;; Revision 1.1 88/11/28 12:11:27 liberte
;;; Initial revision
(defun edebug-window-list ()
"Return a list of windows, in order of next-window."
- ;; This doesnt work for epoch.
+ ;; This doesn't work for epoch.
(let* ((first-window (selected-window))
(window-list (list first-window))
(next (next-window first-window)))
(nreverse value-value-list)))
-;; Bug: this doesnt support condition name lists
+;; Bug: this doesn't support condition name lists
(put 'condition-case 'edebug-form-hook
'(symbolp
form
(eq edebug-arg-mode 'error))
(progn
(setq edebug-mode 'step)
- (edebug-overlay-arrow) ; this doesnt always show up.
+ (edebug-overlay-arrow) ; this doesn't always show up.
(edebug-recursive-edit));; <<<<<< Recursive edit
)
"Number of highest bit")
(defconst mantissa-maxval (1- (ash 1 maxbit))
- "Maximum permissable value of mantissa")
+ "Maximum permissible value of mantissa")
(defconst mantissa-minval (ash 1 maxbit)
- "Minimum permissable value of mantissa")
+ "Minimum permissible value of mantissa")
(defconst floating-point-regexp
"^[ \t]*\\(-?\\)\\([0-9]*\\)\
(parse-partial-sexp (point) last-sexp 0 t)
(backward-prefix-chars)))))
;; Point is at the point to indent under unless we are inside a string.
- ;; Call indentation hook except when overriden by lisp-indent-offset
+ ;; Call indentation hook except when overridden by lisp-indent-offset
;; or if the desired indentation has already been computed.
(let ((normal-indent (current-column)))
(cond ((elt state 3)
;;; Commentary:
-;; Lisp ediing commands to go with Lisp major mode.
+;; Lisp editing commands to go with Lisp major mode.
;;; Code:
default-B the merge buffer contains the B variant by default,
but this difference hasn't been selected yet, so
change-default commands can alter it
- prefer-A in a three-file merge, the A variant is the prefered
+ prefer-A in a three-file merge, the A variant is the preferred
choice
- prefer-B in a three-file merge, the B variant is the prefered
+ prefer-B in a three-file merge, the B variant is the preferred
choice")
(emerge-defvar-local emerge-current-difference -1
"The difference that is currently selected.")
(t
(error "Unrecognized entry"))))
;; If the match on the entry pattern failed
- (error "Unparseable entry")))
+ (error "Unparsable entry")))
;; Make sure that file-A and file-B are present
(if (not (or (and file-A file-B) file-out))
(error "Must have both `A' and `B' entries"))
(defun emerge-join-differences (arg)
"Join the selected difference with the following one.
-With a prefix argument, join with the preceeding one."
+With a prefix argument, join with the preceding one."
(interactive "P")
(let ((n emerge-current-difference))
;; adjust n to be first difference to join
(if (< index emerge-number-of-differences)
index
(error "No difference contains or follows point")))
- ;; if the arg is negative, select the preceeding difference
+ ;; if the arg is negative, select the preceding difference
(t
(if (> index 0)
(1- index)
- (error "No difference contains or preceeds point")))))))
+ (error "No difference contains or precedes point")))))))
(defun emerge-line-numbers ()
"Display the current line numbers.
(global-set-key "\C-j" edt-mode-old-linefeed)) ;"LineFeed"
(defvar GOLD-map (make-keymap)
- "`GOLD-map' maps the function keys on the VT100 keyboard preceeded
+ "`GOLD-map' maps the function keys on the VT100 keyboard preceded
by the PF1 key. GOLD is the ASCII the 7-bit escape sequence <ESC>OP.")
(defalias 'GOLD-prefix GOLD-map)
;;; Commentary:
-;; This package conversts Mocklisp code written under a Gosling or UniPress
+;; This package converts Mocklisp code written under a Gosling or UniPress
;; Emacs for use with GNU Emacs. The translated code will require runtime
;; support from the mlsupport.el equivalent.
"Save last direction, char and upto-flag used for char finding.")
(defvar vi-last-change-command nil ; cons cell
- "Save commmands for redoing last changes. Each command is in (FUNC . ARGS)
+ "Save commands for redoing last changes. Each command is in (FUNC . ARGS)
form that is ready to be 'apply'ed.")
(defvar vi-last-shell-command nil ; last shell op command line
(defun vi-char-argument (arg)
"Get following character (could be any CHAR) as part of the prefix argument.
-Possible perfix-arg cases are NIL, INTEGER, (NIL . CHAR) or (INTEGER . CHAR)."
+Possible prefix-arg cases are NIL, INTEGER, (NIL . CHAR) or (INTEGER . CHAR)."
(interactive "P")
(let ((char (read-char)))
(cond ((null arg) (setq prefix-arg (cons nil char)))
(vi-ask-for-info char))))
(defun vi-mark-region (arg region)
- "Mark region approriately. The next char REGION is d(efun),s(-exp),b(uffer),
+ "Mark region appropriately. The next char REGION is d(efun),s(-exp),b(uffer),
p(aragraph), P(age), f(unction in C/Pascal etc.), w(ord), e(nd of sentence),
l(ines)."
(interactive "p\nc")
(defvar vip-d-com nil
"If non-nil, it's value is a list (M-COM VAL COM), and is used to
-re-execute last destrcutive command")
+re-execute last destructive command")
(defconst vip-shift-width 8
"*The number of colums shifted by > and < command.")
"*If t then do regexp replace, if nil then do string replace.")
(defvar vip-d-char nil
- "The character remenbered by the vi \"r\" command")
+ "The character remembered by the vi \"r\" command")
(defvar vip-f-char nil
"for use by \";\" command")
(vip-escape-to-emacs arg '(?\C-h)))
\f
-;; prefix argmument for vi mode
+;; prefix argument for vi mode
;; In vi mode, prefix argument is a dotted pair (NUM . COM) where NUM
;; represents the numeric value of the prefix argument and COM represents
(setq cont nil))
;; if com is nil we set com as char, and read more. again, if char
;; is ", we read the name of register and store it in vip-use-register.
- ;; if char is !, =, or #, a copmlete com is formed so we exit while.
+ ;; if char is !, =, or #, a complete com is formed so we exit while.
(cond ((or (= char ?!) (= char ?=))
(setq com char)
(setq char (read-char))
com (vip-getcom arg))
(if (null val)
(if (null com)
- (message "Value is nil, and commmand is nil.")
+ (message "Value is nil, and command is nil.")
(message "Value is nil, and command is %c." com))
(if (null com)
(message "Value is %d, and command is nil." val)
reg))))
(defun vip-repeat (arg)
- "(ARG) Re-excute last destructive command. vip-d-com has the form
+ "(ARG) Re-execute last destructive command. vip-d-com has the form
(COM ARG CH REG), where COM is the command to be re-executed, ARG is the
argument for COM, CH is a flag for repeat, and REG is optional and if exists
is the name of the register for COM."
(if com (vip-execute-com 'vip-goto-line val com))))
(defun vip-find-char (arg char forward offset)
- "Find ARG's occurence of CHAR on the current line. If FORWARD then
+ "Find ARG's occurrence of CHAR on the current line. If FORWARD then
search is forward, otherwise backward. OFFSET is used to adjust point
after search."
(let ((arg (if forward arg (- arg))) point)
;; searching
(defun vip-search-forward (arg)
- "Search a string forward. ARG is used to find the ARG's occurence
+ "Search a string forward. ARG is used to find the ARG's occurrence
of the string. Default is vanilla search. Search mode can be toggled by
giving null search string."
(interactive "P")
(vip-execute-com 'vip-search-next val com))))))
(defun vip-search-backward (arg)
- "Search a string backward. ARG is used to find the ARG's occurence
+ "Search a string backward. ARG is used to find the ARG's occurrence
of the string. Default is vanilla search. Search mode can be toggled by
giving null search string."
(interactive "P")
"pattern for global command")
(defvar ex-map (make-sparse-keymap)
- "save commnads for mapped keys")
+ "save commands for mapped keys")
(defvar ex-tag nil
"save ex tag")
(forward-line (1- ex-count)))
(set-mark end))
(vip-enlarge-region (point) (mark))
- (if ex-flag (error "Extra chacters at end of command"))
+ (if ex-flag (error "Extra characters at end of command"))
(if ex-buffer
(copy-to-register ex-buffer (point) (mark) nil))
(copy-region-as-kill (point) (mark)))))
(defun ws-indent-block ()
- "In WordStar mode: Indent block (not yet implemeted)."
+ "In WordStar mode: Indent block (not yet implemented)."
(interactive)
(ws-error "Indent block not yet implemented"))
;; would mean that our line of output would not display
;; FILE's name as given. To really address the problem that
;; SunOS 4.1.3 has, we need to find the right switch to get
- ;; a descripton of the link itself.
+ ;; a description of the link itself.
;; (let (symlink)
;; (while (setq symlink (file-symlink-p file))
;; (setq file symlink)))
Pop-up frames are used for completions, help, and the like.
This variable can be set in your init file, like this:
(setq pop-up-frame-alist '((width . 80) (height . 20)))
-These supercede the values given in `default-frame-alist'.")
+These supersede the values given in `default-frame-alist'.")
(setq pop-up-frame-function
(function (lambda ()
;;;; Creation of additional frames, and other frame miscellanea
;;; Return some frame other than the current frame, creating one if
-;;; neccessary. Note that the minibuffer frame, if separate, is not
+;;; necessary. Note that the minibuffer frame, if separate, is not
;;; considered (see next-frame).
(defun get-other-frame ()
(let ((s (if (equal (next-frame (selected-frame)) (selected-frame))
;;; GNUS: an NNTP-based News Reader for GNU Emacs
;; Copyright (C) 1987, 1988, 1989, 1990, 1993 Free Software Foundation, Inc.
-;; $Header: /home/fsf/rms/e19/lisp/RCS/gnus.el,v 1.17 1993/06/04 05:33:32 rms Exp rms $
+;; $Header: /gd/gnu/emacs/19.0/lisp/RCS/gnus.el,v 1.18 1993/06/05 09:17:34 rms Exp jimb $
;; This file is part of GNU Emacs.
(defvar gnus-use-followup-to t
"*Specifies what to do with Followup-To: field.
-If nil, ignore followup-to: field. If t, use its value execpt for
-`poster'. Otherewise, if not nil nor t, always use its value.")
+If nil, ignore followup-to: field. If t, use its value except for
+`poster'. Otherwise, if not nil nor t, always use its value.")
(defvar gnus-large-newsgroup 50
"*The number of articles which indicates a large newsgroup.
result must be a string excluding `[' and `]'.")
(defvar gnus-auto-extend-newsgroup t
- "*Extend visible artciles to forward and backward if non-nil.")
+ "*Extend visible articles to forward and backward if non-nil.")
(defvar gnus-auto-select-first t
"*Select the first unread article automagically if non-nil.
(defun gnus-summary-next-page (lines)
"Show next page of selected article.
-If end of artile, select next article.
+If end of article, select next article.
Argument LINES specifies lines to be scrolled up."
(interactive "P")
(let ((article (gnus-summary-article-number))
(gnus-eval-in-buffer-window gnus-article-buffer
;; Look for parent Message-ID.
;; We cannot use gnus-current-headers to get references
- ;; because we may be looking at parent or refered article.
+ ;; because we may be looking at parent or referred article.
(let ((references (gnus-fetch-field "References")))
;; Get the last message-id in the references.
(and references
(setq message-id (concat message-id ">")))
;; Push current message-id on history.
;; We cannot use gnus-current-headers to get current
- ;; message-id because we may be looking at parent or refered
+ ;; message-id because we may be looking at parent or referred
;; article.
(let ((current (gnus-fetch-field "Message-ID")))
(or (equal current message-id) ;Nothing to do.
(let ((newsgroup (substring newsgroup 0)) ;Copy string.
(len (length newsgroup))
(idx 0))
- ;; Replace all occurence of `.' with `/'.
+ ;; Replace all occurrences of `.' with `/'.
(while (< idx len)
(if (= (aref newsgroup idx) ?.)
(aset newsgroup idx ?/))
(defun gnus-define-access-method (method &optional access-methods)
"Define access functions for the access METHOD.
-Methods defintion is taken from optional argument ACCESS-METHODS or
+Methods definition is taken from optional argument ACCESS-METHODS or
the variable gnus-access-methods."
(let ((bindings
(cdr (assoc method (or access-methods gnus-access-methods)))))
(setq defs (car overloads))
(setq overloads (cdr overloads))
;; Load file before overloading function if necessary. Make
- ;; sure we cannot use `requre' always.
+ ;; sure we cannot use `require' always.
(and (not (fboundp (car defs)))
(car (cdr (cdr defs)))
(load (car (cdr (cdr defs))) nil 'nomessage))
(defun gnus-group-yank-group ()
"Yank the last newsgroup killed with \\[gnus-group-kill-group],
-inserting it before the newsgroup on the line containging point."
+inserting it before the newsgroup on the line containing point."
(interactive)
(gnus-group-insert-group (car gnus-killed-assoc))
;; Remove killed newsgroups from the buffer if exists.
;; The job of the marker-filter method is to detect file/line markers in
;; strings and set the global gud-last-frame to indicate what display
;; action (if any) should be triggered by the marker. Note that only
-;; whetever the method *returns* is displayed in the buffer; thus, you
+;; whatever the method *returns* is displayed in the buffer; thus, you
;; can filter the debugger's output, interpreting some and passing on
;; the rest.
;;
(defun expr-compound-sep (span-start span-end)
"Returns '.' for '->' & '.', returns ' ' for white space,
-returns '?' for other puctuation."
+returns '?' for other punctuation."
(let ((result ? )
(syntax))
(while (< span-start span-end)
;; Author: Daniel LaLiberte <liberte@cs.uiuc.edu>
-;; |$Date: 1993/06/04 06:40:45 $|$Revision: 1.40 $
+;; |$Date: 1993/06/06 22:11:22 $|$Revision: 1.41 $
;; This file is not yet part of GNU Emacs, but it is based almost
;; entirely on isearch.el which is part of GNU Emacs.
;; the last possible moment.
;; TODO
-;; - Integrate the emacs 19 generalized commmand history.
+;; - Integrate the emacs 19 generalized command history.
;; - Think about incorporating query-replace.
;; - Hooks and options for failed search.
;;;=======================================================
;;; Switching buffers should first terminate isearch-mode.
-;;; This is done quite differently for each varient of emacs.
+;;; This is done quite differently for each variant of emacs.
;;; For lemacs, see Exiting in lemacs below
;; For Emacs 19, the frame switch event is handled.
\\[isearch-forward-exit-minibuffer] to resume isearching forward.
\\[isearch-backward-exit-minibuffer] to resume isearching backward.
\\[isearch-ring-advance-edit] to replace the search string with the next item in the search ring.
-\\[isearch-ring-retreat-edit] to replace the search string with the previou item in the search ring.
+\\[isearch-ring-retreat-edit] to replace the search string with the previous item in the search ring.
\\[isearch-complete-edit] to complete the search string using the search ring.
If first char entered is \\[isearch-yank-word], then do word search instead."
;; Mainly, isearch-mode must be terminated while editing and then restarted.
;; If there were a way to catch any change of buffer from the minibuffer,
;; this could be simplified greatly.
- ;; Editing doesnt back up the search point. Should it?
+ ;; Editing doesn't back up the search point. Should it?
(interactive)
(condition-case err
(let (isearch-nonincremental ; should search nonincrementally?
Otherwise, revert to previous successful search and continue searching.
Use `isearch-exit' to quit without signalling."
(interactive)
-;; (ding) signal instead below, if quiting
+;; (ding) signal instead below, if quitting
(discard-input)
(if isearch-success
;; If search is successful, move back to starting point
(isearch-process-search-string search-whitespace-regexp " ")
(isearch-printing-char))
(progn
- ;; This way of doing word search doesnt correctly extend current search.
+ ;; This way of doing word search doesn't correctly extend current search.
;; (setq isearch-word t)
;; (setq isearch-adjusted t)
;; (goto-char isearch-barrier)
;; system you connect to. A more serious problem is that some brain-dead
;; systems will not recognize a ^J as an end-of-line character. So LFD is
;; bound to a new function which acts just like CR usually does in shell-mode,
-;; but a ^M is sent as an end-of-line. Funcions are also provied to swap the
+;; but a ^M is sent as an end-of-line. Functions are also provided to swap the
;; bindings of CR and LFD. I've also included a filter which will clean out
;; any ^M's or ^@'s that get typed at you, but I don't really recommend it.
;; There doesn't seem to be an acceptably fast way to do this via emacs-lisp.
;; thru a fairly stupid terminal switch. If I want to connect to unix system,
;; then I use the LFD key to talk to the switch, and ignore any ^M's in the
;; buffer, and do a " stty -echo nl " after I log in. Then the only real
-;; differnce from being in local shell-mode is that it is you need to to type
+;; difference from being in local shell-mode is that you need to type
;; ^C^Q^C to send an interrupt, and ^C^Q^Z for a stop signal, etc. (since ^C^C
;; just generates a local stop signal, which kermit ignores).
;; To connect to a VMS system, I use a shell script to invoke kermit thru the
;; in order to do a file transfer, you have to think ahead and and add -r
;; (receive) to the command line. This means that you can't use the server
;; feature. The only fix I can see is to muck around with the source code for
-;; kermit, although this problably wouldn't be too hard. What is needed is an
+;; kermit, although this probably wouldn't be too hard. What is needed is an
;; option to force kermit to be local, to use stdin and stdout for interactive
;; speech, and to forget about cbreak mode.
(with-output-to-temp-buffer "*Help*"
(princ
(substitute-command-keys
- "Specify how to procede with keyboard macro execution.
+ "Specify how to proceed with keyboard macro execution.
Possibilities: \\<query-replace-map>
\\[act] Finish this iteration normally and continue with the next.
\\[skip] Skip the rest of this iteration, and start the next.
;;; fred, ethyl, larry, curly, moe
;;;
;;; Aliases may also contain forward references; the alias of "everybody" can
-;;; preceed the aliases of "group1" and "group2".
+;;; precede the aliases of "group1" and "group2".
;;;
;;; This code also understands the "source" .mailrc command, for reading
;;; aliases from some other file as well.
(defvar mail-mode-header-syntax-table
(let ((tab (copy-syntax-table text-mode-syntax-table)))
- ;; This makes the characters "@%!._-" be considered symbol-consituents
+ ;; This makes the characters "@%!._-" be considered symbol-constituents
;; but not word-constituents, so forward-sexp will move you over an
;; entire address, but forward-word will only move you over a sequence
;; of alphanumerics. (Clearly the right thing.)
;; Show the first unseen message, which might be from a previous session
;; or might have been just read in by rmail-get-new-mail. Must
;; determine already unseen messages first, as rmail-get-new-mail
- ;; positions on the first new messsage, thus marking it as seen.
+ ;; positions on the first new message, thus marking it as seen.
(rmail-show-message existing-unseen))))
;; Given the value of MAILPATH, return a list of inbox file names.
;; Eric Rose <erose@jessica.stanford.edu>, submitted manual.el which
;; provided a very nice manual browsing mode.
-;; This package was available as `superman.el' from the LCD paackage
+;; This package was available as `superman.el' from the LCD package
;; for some time before it was accepted into Emacs 19. The entry
;; point and some other names have been changed to make it a drop-in
;; replacement for the old man.el package.
"*Association list of bogus sections to real section numbers.
Some manpages (e.g. the Sun C++ 2.1 manpages) have section numbers in
their references which Un*x man(1) does not recognize. This
-assocation list is used to translate those sections, when found, to
+association list is used to translate those sections, when found, to
the associated section number.")
(defvar Man-filter-list
;;; Modified by James Larus, BBN, July 1984 and UCB, 1984 & 1985.
;;; Rewritten for GNU Emacs, James Larus 1985. larus@ginger.berkeley.edu
;;; Modified by Stephen Gildea 1988. gildea@bbn.com
-(defconst mh-e-RCS-id "$Header: /home/fsf/rms/e19/lisp/RCS/mh-e.el,v 1.10 1993/05/30 22:56:31 rms Exp rms $")
+(defconst mh-e-RCS-id "$Header: /home/gd/gnu/emacs/19.0/lisp/RCS/mh-e.el,v 1.11 1993/06/05 02:51:21 rms Exp jimb $")
;;; Code:
"String whose first character is used to notate redistributed messages.")
(defvar mh-good-msg-regexp "^....[^D^]"
- "Regexp specifiying the scan lines that are 'good' messages.")
+ "Regexp specifying the scan lines that are 'good' messages.")
(defvar mh-deleted-msg-regexp "^....D"
"Regexp matching scan lines of deleted messages.")
;;; The folder data abstraction.
(defvar mh-current-folder nil "Name of current folder, a string.")
-(defvar mh-show-buffer nil "Buffer that displays mesage for this folder.")
+(defvar mh-show-buffer nil "Buffer that displays message for this folder.")
(defvar mh-folder-filename nil "Full path of directory for this folder.")
(defvar mh-showing nil "If non-nil, show the message in a separate window.")
(defvar mh-next-seq-num nil "Index of free sequence id.")
provided now. I suppose the later is faster.")
(defvar mhspool-list-directory-switches '("-R")
- "*Switches for mhspool-list-folders-using-ls to pass to `ls' for gettting file lists.
+ "*Switches for mhspool-list-folders-using-ls to pass to `ls' for getting file lists.
One entry should appear on one line. You may need to add `-1' option.")
\f
(let ((string (substring string 0)) ;Copy string.
(len (length string))
(idx 0))
- ;; Replace all occurence of FROM with TO.
+ ;; Replace all occurrences of FROM with TO.
(while (< idx len)
(if (= (aref string idx) from)
(aset string idx to))
<FOO ...> will be indented n spaces from start of form.
\(put 'FOO 'indent-mim-function 'DEFINE\) is like above but means use
value of mim-body-indent as offset from start of form.
-\(put 'FOO 'indent-mim-function <cons>\) where <cons> is a list or pointted list
+\(put 'FOO 'indent-mim-function <cons>\) where <cons> is a list or pointed list
of integers, means indent each form in <FOO ...> by the amount specified
in <cons>. When <cons> is exhausted, indent remaining forms by
`mim-body-indent' unless <cons> is a pointed list, in which case the last
"Move forward across Mim object.
With ARG, move forward that many objects."
(interactive "p")
- ;; this function is wierd because it emulates the behavior of the old
+ ;; this function is weird because it emulates the behavior of the old
;; (gosling) mim-mode - if the arg is 1 and we are `inside' an ADECL,
;; more than one character into the ATOM part and not sitting on the
;; colon, then we move to the DECL part (just past colon) instead of
"Move down a level of Mim structure forwards.
With ARG, move down that many levels forwards (backwards, ARG < 0)."
(interactive "p")
- ;; another wierdo - going down `inside' an ADECL or ATOM trailer
+ ;; another weirdo - going down `inside' an ADECL or ATOM trailer
;; depends on the value of mim-down-parens-only. if nil, treat
;; ADECLs and trailers as structured objects.
(let ((direction (sign (or arg (setq arg 1)))))
(+ method start))
(goto-char current-indent)
(if (consp method)
- ;; list or pointted list of explicit indentations
+ ;; list or pointed list of explicit indentations
(indent-mim-offset state indent-point)
(if (and (symbolp method) (fboundp method))
;; luser function - s/he better know what's going on.
(last-sexp (car (nthcdr 2 state)))
indentation)
(goto-char (1+ containing-sexp))
- ;; determine wheich of the indentations to use.
+ ;; determine which of the indentations to use.
(while (and (< (point) indent-point)
(condition-case nil
(progn (forward-sexp 1)
(setq nntp-server-process nil))
(defun nnspool-find-article-by-message-id (id)
- "Return full pathname of an artilce identified by message-ID."
+ "Return full pathname of an article identified by message-ID."
(save-excursion
(let ((buffer (get-file-buffer nnspool-history-file)))
(if buffer
(let ((string (substring string 0)) ;Copy string.
(len (length string))
(idx 0))
- ;; Replace all occurence of FROM with TO.
+ ;; Replace all occurrences of FROM with TO.
(while (< idx len)
(if (= (aref string idx) from)
(aset string idx to))
"Send list of STRINGS to news server as command and its arguments."
(let ((cmd (car strings))
(strings (cdr strings)))
- ;; Command and each argument must be separeted by one or more spaces.
+ ;; Command and each argument must be separated by one or more spaces.
(while strings
(setq cmd (concat cmd " " (car strings)))
(setq strings (cdr strings)))
(define-key blackbox-mode-map "\C-m" 'bb-done)
(define-key blackbox-mode-map [kp-enter] 'bb-done)
- ;; This is a kluge. What we really want is a general
+ ;; This is a kludge. What we really want is a general
;; feature for reminding terminal keys to the functions
;; corresponding to them in local maps.
(mapcar (function
;;; Commentary:
-;; The single entry point, `dissociatesd-press', applies a travesty
+;; The single entry point, `dissociated-press', applies a travesty
;; generator to the current buffer. The results can be quite amusing.
;;; Code:
(setq deathlst
'((this is not a healthy way of thinking \.)
(($ bother) you\, too\, may die someday \?)
- (i am worried by your obssession with this topic!)
+ (i am worried by your obsession with this topic!)
(did you watch a lot of crime and violence on television as a child \?))
)
(make-local-variable 'sexlst)
(doctor-put-meaning elisa 'eliza)
(doctor-put-meaning weizenbaum 'eliza)
(doctor-put-meaning doktor 'eliza)
-(doctor-put-meaning atheletics 'sports)
+(doctor-put-meaning athletics 'sports)
(doctor-put-meaning baseball 'sports)
(doctor-put-meaning basketball 'sports)
(doctor-put-meaning football 'sports)
sent))))
(defun doctor-shorten (sent)
- "Make a sentence managably short using a few hacks."
+ "Make a sentence manageably short using a few hacks."
(let (foo
retval
(temp '(because but however besides anyway until
applied applies apply are associate
associated ate
be became become becomes becoming
- been being believe belived believes
+ been being believe believed believes
bit bite bites bore bored bores boring bought buy buys buying
call called calling calls came can caught catch come
contract contracted contracts control controlled controls
dislikes do does drank drink drinks drinking
drive drives driving drove dying
eat eating eats expand expanded expands
- expect expected expects expel expels expeled expelled
+ expect expected expects expel expels expelled
explain explained explains
fart farts feel feels felt fight fights find finds finding
forget forgets forgot fought found fuck fucked
take takes taking talk talked talking talks tell tells telling
think thinks
thought told took tooled touch touched touches touching
- transfer transfered transfers transmit transmits transmitted
+ transfer transferred transfers transmit transmits transmitted
type types types typing
walk walked walking walks want wanted wants was watch
watched watching went were will wish would work worked works
hundred thousand million billion
half quarter
first second third fourth fifth
- sixth seventh eighth nineth tenth)))
+ sixth seventh eighth ninth tenth)))
(defun doctor-colorp (x)
(memq x '(beige black blue brown crimson
;; If we have NRINGS rings, we label them with the numbers 0
;; through NRINGS-1. The width of ring i is 2i+3; it pokes
;; out i spaces on either side of the pole. Rather than
- ;; checking if the window is wide enough to accomodate this,
+ ;; checking if the window is wide enough to accommodate this,
;; we make sure pole-spacing is large enough, since that
;; works even when we have decremented pole-spacing to make
;; it even.
;; A demonstrator for John Horton Conway's "Life" cellular automaton
;; in Emacs Lisp. Picks a random one of a set of interesting Life
-;; patterns and avolves it according to the familiar rules.
+;; patterns and evolves it according to the familiar rules.
;;; Code:
(defmacro life-not-void-regexp () (concat "[^" (life-void-string) "\n]"))
;; try to optimize the (goto-char (point-min)) & (goto-char (point-max))
-;; idioms. This depends on goto-char's not griping if we underrshoot
+;; idioms. This depends on goto-char's not griping if we undershoot
;; or overshoot beginning or end of buffer.
(defmacro goto-beginning-of-buffer () '(goto-char 1))
(defmacro maxint () (lsh (lsh (lognot 0) 1) -1))
(aset mpuz-letter-to-digit elem index))))
-;; A puzzle also uses a board displaying a mulplication.
+;; A puzzle also uses a board displaying a multiplication.
;; Every digit appears in the board, crypted or not.
;;------------------------------------------------------
(defvar mpuz-board (make-vector 10 nil)
;; Game control
;;-------------
(defun mpuz-abort-game ()
- "Abort any puzzle in progess."
+ "Abort any puzzle in progress."
(message "Mult Puzzle aborted.")
(setq mpuz-in-progress nil
mpuz-nb-errors 0)
;;; Commentary:
-;; Important pinheaddery for GNU Emacs.
+;; Important pinheadery for GNU Emacs.
;;
;; See cookie1.el for implementation. Note --- the `n' argument of yow
;; from the 18.xx implementation is no longer; we only support *random*
(defun c-beginning-of-statement (count)
"Go to the beginning of the innermost C statement.
With prefix arg, go back N - 1 statements. If already at the beginning of a
-statement then go to the beginning of the preceeding one.
+statement then go to the beginning of the preceding one.
If within a string or comment, or next to a comment (only whitespace between),
move by sentences instead of statements."
(interactive "p")
;; (defconst c++-defun-header-strong
;; (let*
;; (; valid identifiers
-;; ;; There's a real wierdness here -- if I switch the below
+;; ;; There's a real weirdness here -- if I switch the below
;; (id "\\(\\w\\|_\\)+")
;; ;; to be
;; ;; (id "\\(_\\|\\w\\)+")
(defvar tags-included-tables-function nil
"Function to do the work of `tags-included-tables' (which see).")
(defvar verify-tags-table-function nil
- "Function to return t iff the current buffer vontains a valid
+ "Function to return t iff the current buffer contains a valid
\(already initialized\) tags file.")
\f
;; Initialize the tags table in the current buffer.
;; Move to the saved location.
(set-buffer (marker-buffer marker))
(goto-char (marker-position marker))
- ;; Kill that marker so it doesn't slow down editting.
+ ;; Kill that marker so it doesn't slow down editing.
(set-marker marker nil nil)
;; Run the user's hook. Do we really want to do this for pop?
(run-hooks 'local-find-tag-hook))))
;; Fortran mode has been upgraded and is now maintained by Stephen A. Wood
;; (saw@cebaf.gov). It now will use either fixed format continuation line
-;; markers (character in 6th column), or tab format coninuation line style
+;; markers (character in 6th column), or tab format continuation line style
;; (digit after a TAB character.) A auto-fill mode has been added to
;; automatically wrap fortran lines that get too long.
;; Gary Sabot and Richard Stallman.
;;; This file may be used with GNU Emacs version 18.xx if the following
-;;; variable and function substutions are made.
+;;; variable and function substitutions are made.
;;; Replace:
;;; frame-width with screen-width
;;; auto-fill-function with auto-fill-hook
style.")
(defvar fortran-break-before-delimiters t
- "*Non-nil causes `fortran-do-auto-fill' to break lines before delimeters.")
+ "*Non-nil causes `fortran-do-auto-fill' to break lines before delimiters.")
(if fortran-mode-syntax-table
()
Non-nil causes line number digits to be moved to the correct column
as typed. (default t)
fortran-break-before-delimiters
- Non-nil causes `fortran-do-auto-fill' breaks lines before delimeters.
+ Non-nil causes `fortran-do-auto-fill' breaks lines before delimiters.
(default t)
fortran-startup-message
Set to nil to inhibit message first time Fortran mode is used.
;; decide where to split the line. If a position for a quoted
;; string was found above then use that, else break the line
;; before the last delimiter.
- ;; Delimeters are whitespace, commas, and operators.
+ ;; Delimiters are whitespace, commas, and operators.
;; Will break before a pair of *'s.
;;
(fill-point
((hif-looking-at-endif)
'done)
(t
- (error "Missmatched #ifdef #endif pair"))))
+ (error "Mismatched #ifdef #endif pair"))))
(defun hif-endif-to-ifdef ()
(let ((start (point)))
(hif-find-previous-relevant)
(if (= start (point))
- (error "Missmatched #ifdef #endif pair")))
+ (error "Mismatched #ifdef #endif pair")))
(cond ((hif-looking-at-endif)
(hif-endif-to-ifdef) ; find beginning of nested if
(hif-endif-to-ifdef)) ; find beginning of outer if or else
(defun hif-find-ifdef-block ()
- "Utilitiy for hide and show `ifdef-block'.
+ "Utility for hide and show `ifdef-block'.
Set top and bottom of ifdef block."
(let (max-bottom)
(save-excursion
(if old-read-only (toggle-read-only))))
-;;; defininition alist support
+;;; definition alist support
(defvar hide-ifdef-define-alist nil
"A global assoc list of pre-defined symbol lists")
processes, you can change inferior-lisp-buffer to another process
buffer with \\[set-variable].
-More sophisticated approaches are, of course, possible. If you find youself
+More sophisticated approaches are, of course, possible. If you find yourself
needing to switch back and forth between multiple processes frequently,
you may wish to consider ilisp.el, a larger, more sophisticated package
for running inferior Lisp processes. The approach taken here is for a
;; So, for the meantime, this is not the default mode for makefiles.
-;; $Id: makefile.el,v 1.7 1993/04/21 03:47:05 eric Exp rms $
+;; $Id: makefile.el,v 1.8 1993/05/06 01:30:26 rms Exp jimb $
;; This file is part of GNU Emacs.
(provide 'makefile)
;;; ------------------------------------------------------------
-;;; Configureable stuff
+;;; Configurable stuff
;;; ------------------------------------------------------------
(defconst makefile-mode-name "makefile"
"Controls the style of generated macro references.
Set this variable to a non-nil value if you prefer curly braces
in macro-references, so it looks like ${this}. A value of nil
-will cause makefile-mode to use parantheses, making macro references
+will cause makefile-mode to use parentheses, making macro references
look like $(this) .")
(defvar makefile-tab-after-target-colon t
;;; ------------------------------------------------------------
;;; The following configurable variables are used in the
;;; up-to-date overview .
-;;; The standard configuration assumes that your `make' programm
+;;; The standard configuration assumes that your `make' program
;;; can be run in question/query mode using the `-q' option, this
;;; means that the command
;;;
;;; Dennis Vadura's DMake have no problems.
;;; Set the variable `makefile-brave-make' to the name of the
;;; make utility that does this on your system.
-;;; To understand what this is all about see the function defintion
+;;; To understand what this is all about see the function definition
;;; of `makefile-query-by-make-minus-q' .
;;; ------------------------------------------------------------
This function \'knows\' about the required parameters of every
GNU make function and will use meaningfull prompts for the
various args, making it much easier to take advantage of this
-powerfull GNU make feature."
+powerful GNU make feature."
(interactive)
(let* ((gm-function-name (completing-read
"Function: "
;; Known problems (these are all caused by limitations in the Emacs Lisp
;; parsing routine (parse-partial-sexp), which was not designed for such
;; a rich language; writing a more suitable parser would be a big job):
-;; 1) Regular expression delimitors do not act as quotes, so special
+;; 1) Regular expression delimiters do not act as quotes, so special
;; characters such as `'"#:;[](){} may need to be backslashed
;; in regular expressions and in both parts of s/// and tr///.
;; 2) The globbing syntax <pattern> is not recognized, so special
(if first-sexp-list-p
(setq desired-indent (current-column)))
;; Point is at the point to indent under unless we are inside a string.
- ;; Call indentation hook except when overriden by scheme-indent-offset
+ ;; Call indentation hook except when overridden by scheme-indent-offset
;; or if the desired indentation has already been computed.
(cond ((car (nthcdr 3 state))
;; Inside a string, don't change indentation.
(defconst simula-if-indent '(0 . 0)
"*Extra indentation of THEN and ELSE with respect to the starting IF.
-Value is a cons cell, the car is extra THEN indention and the cdr
-extra ELSE indention. IF after ELSE is indented as the starting IF.")
+Value is a cons cell, the car is extra THEN indentation and the cdr
+extra ELSE indentation. IF after ELSE is indented as the starting IF.")
(defconst simula-inspect-indent '(0 . 0)
"*Extra indentation of WHEN and OTHERWISE with respect to the
corresponding INSPECT. Value is a cons cell, the car is
-extra WHEN indention and the cdr extra OTHERWISE indention.")
+extra WHEN indentation and the cdr extra OTHERWISE indentation.")
(defconst simula-electric-indent nil
"*If this variable is non-nil, the simula-indent-line function
Offset of SIMULA label lines relative to usual indentation
simula-if-indent '(0 . 0)
Extra indentation of THEN and ELSE with respect to the starting IF.
- Value is a cons cell, the car is extra THEN indention and the cdr
- extra ELSE indention. IF after ELSE is indented as the starting IF.
+ Value is a cons cell, the car is extra THEN indentation and the cdr
+ extra ELSE indentation. IF after ELSE is indented as the starting IF.
simula-inspect-indent '(0 . 0)
Extra indentation of WHEN and OTHERWISE with respect to the
corresponding INSPECT. Value is a cons cell, the car is
- extra WHEN indention and the cdr extra OTHERWISE indention.
+ extra WHEN indentation and the cdr extra OTHERWISE indentation.
simula-electric-indent nil
If this variable non-nil value, simula-indent-line
will check the previous line to see if it has to be reindented.
with no arguments, if that value is non-nil
Warning: simula-mode-hook should not read in an abbrev file without calling
-the function simula-install-standard-abbrevs afterwards, preferrably not
+the function simula-install-standard-abbrevs afterwards, preferably not
at all."
(interactive)
(kill-all-local-variables)
;; Calculate non-comment indentation
(t
;; first, find out if this line starts with something that needs
- ;; special indention (END/IF/THEN/ELSE/WHEN/OTHERWISE or label)
+ ;; special indentation (END/IF/THEN/ELSE/WHEN/OTHERWISE or label)
;;
(skip-chars-forward " \t\f")
(cond
(cdr simula-if-indent))))
(simula-find-inspect)))
;; found the start of a [sub]statement
- ;; add indention for continued statement
+ ;; add indentation for continued statement
(if continued
(setq indent
(+ indent
"begin\\|then\\|else\\|when\\|otherwise\\|do")))
(not (memq (preceding-char) '(?: ?\;))))))
;; if we the state of the continued-variable
- ;; changed, add indention for continued statement
+ ;; changed, add indentation for continued statement
(if (or (and prev-cont (not continued))
(and continued
(listp simula-continued-statement-offset)))
(setq start-line (save-excursion (beginning-of-line) (point)))
(beginning-of-line))))
;;
- ;; return indention
+ ;; return indentation
;;
indent)))))
((eq (following-char) ?\;)
(if (zerop parlevel)
(throw 'simula-out nil)
- (error "Parethesis mismatch or misplaced ';'")))
+ (error "Parenthesis mismatch or misplaced ';'")))
((eq (following-char) ?\()
(if (zerop parlevel)
(throw 'simula-out (1+ (current-column)))
"Expand SIMULA keyword. If it starts the line, reindent."
;; redisplay
(let ((show-char (eq this-command 'self-insert-command)))
- ;; If the abbrev expansion results in reindention, the user may have
+ ;; If the abbrev expansion results in reindentation, the user may have
;; to wait some time before the character he typed is displayed
;; (the char causing the expansion is inserted AFTER the hook function
;; is called). This is annoying in case of normal characters.
;; massages raw reply buffers set up by the reply/forward functions in
;; the news/mail subsystems. Therefore, such useful operations as
;; yanking and citing portions of the original article (instead of the
-;; whole article) are not within the ability or responsiblity of
+;; whole article) are not within the ability or responsibility of
;; supercite.
;; ========== Disclaimer ==========
\f
;; ======================================================================
-;; global variables, not user accessable
+;; global variables, not user accessible
(defconst sc-version-number "2.3"
"Supercite's version number.")
())
(defun sc-no-blank-line-or-header()
- "Similar to sc-no-header except it removes the preceeding blank line."
+ "Similar to sc-no-header except it removes the preceding blank line."
(if (not (bobp))
(if (and (eolp)
(progn (forward-line -1)
(run-hooks 'sc-fill-paragraph-hook)))
(setq fstart (point)
fend (point)))
- ;; not end of line so perhap cite it
+ ;; not end of line so perhaps cite it
((not (looking-at sc-cite-regexp))
(insert (aget sc-gal-information "sc-citation")))
(sc-nested-citation-p
;;
(defun sc-describe ()
"Supercite version 2.3 is now described in a texinfo manual which
-makes the documenation available both for online perusal via emacs'
+makes the documentation available both for online perusal via emacs'
info system, or for hard-copy printing using the TeX facility.
To view the online document hit \\[info], then \"mSupercite <RET>\"."
(goto-char (point-min)))
(defun count-lines-region (start end)
- "Print number of lines and charcters in the region."
+ "Print number of lines and characters in the region."
(interactive "r")
(message "Region has %d lines, %d characters"
(count-lines start end) (- end start)))
\f
;;;###autoload
(defun sort-regexp-fields (reverse record-regexp key-regexp beg end)
- "Sort the region lexicographically as specifed by RECORD-REGEXP and KEY.
+ "Sort the region lexicographically as specified by RECORD-REGEXP and KEY.
RECORD-REGEXP specifies the textual units which should be sorted.
For example, to sort lines RECORD-REGEXP would be \"^.*$\"
KEY specifies the part of each record (ie each match for RECORD-REGEXP)
(defalias 'not 'null)
(defalias 'rplaca 'setcar)
(defalias 'rplacd 'setcdr)
-(defalias 'beep 'ding) ;preserve lingual purtity
+(defalias 'beep 'ding) ;preserve lingual purity
(defalias 'indent-to-column 'indent-to)
(defalias 'backward-delete-char 'delete-backward-char)
(defalias 'search-forward-regexp (symbol-function 're-search-forward))
;;;
;;;
;;; Functions for manipulating via the mouse and mouse-map definitions
-;;; for accessing them. Also definitons of mouse menus.
+;;; for accessing them. Also definitions of mouse menus.
;;; This file you should freely modify to reflect you personal tastes.
;;;
;;; First half of file defines functions to implement mouse commands,
;;; Mouse Functions.
;;;
;;; These functions follow the sun-mouse-handler convention of being called
-;;; with three arguements: (window x-pos y-pos)
+;;; with three arguments: (window x-pos y-pos)
;;; This makes it easy for a mouse executed command to know where the mouse is.
;;; Use the macro "eval-in-window" to execute a function
;;; in a temporarily selected window.
(mouse-select-window window x y)))
;;;
-;;; esoteria:
+;;; esoterica:
;;;
(defun mouse-exch-pt-and-mark (window x y)
"Exchange point and mark."
(if (>= x (1- (window-width)))
;; When x is maximun (equal to or 1 less than window width),
;; goto end of buffer. We check for this special case
- ;; becuase the calculated goto-char often goes short of the
+ ;; because the calculated goto-char often goes short of the
;; end due to roundoff error, and we often really want to go
;; to the end.
(goto-char (point-max))
;;; minibuffer menu
;;;
(defmenu minibuffer-menu
- ("Minibuffer" message "Just some miscellanous minibuffer commands")
+ ("Minibuffer" message "Just some miscellaneous minibuffer commands")
("Stuff" sun-yank-selection)
("Do-It" exit-minibuffer)
("Abort" abort-recursive-edit)
(4) The uses of the "k0" capability are inconsistent; sometimes it
describes F10, whereas othertimes it describes F0 and "k;" describes F10.
- Emacs attempts to politely accomodate both systems by testing for
+ Emacs attempts to politely accommodate both systems by testing for
"k;", and if it is present, assuming that "k0" denotes F0, otherwise F10.
-----------------------------------------------------------------------------
(defun define-mouse (mousemap mouse-list def)
"Args MOUSEMAP, MOUSE-LIST, DEF. Define MOUSE-LIST in MOUSEMAP as DEF.
-MOUSE-LIST is a list of atoms specifing a mouse hit according to these rules:
+MOUSE-LIST is a list of atoms specifying a mouse hit according to these rules:
* One of these atoms specifies the active region of the definition.
text, scrollbar, modeline, minibuffer
* One or two or these atoms specify the button or button combination.
(defmacro sm::hit-x (hit) (list 'nth 1 hit))
;;; Screen y position.
(defmacro sm::hit-y (hit) (list 'nth 2 hit))
-;;; Millisconds since last hit.
+;;; Milliseconds since last hit.
(defmacro sm::hit-delta (hit) (list 'nth 3 hit))
(defmacro sm::hit-up-p (hit) ; A predicate.
(cond ((minibuffer-window-p w) 'minibuffer)
((>= y bottom) 'modeline)
((>= x right) 'scrollbar)
- ;; far right column (window seperator) is always a scrollbar
+ ;; far right column (window separator) is always a scrollbar
((and scrollbar-width
;; mouse within scrollbar-width of edge.
(>= x (- right scrollbar-width))
If the selected form is a menu or a symbol whose value is a menu,
then it is displayed and evaluated as a pullright menu item.
If the the FORM of the first ITEM is nil, the STRING of the item
-is used as a label for the menu, i.e. it's inverted and not selectible."
+is used as a label for the menu, i.e. it's inverted and not selectable."
(if (symbolp menu) (setq menu (symbol-value menu)))
(eval (sun-menu-internal *menu-window* *menu-x* *menu-y* 4 menu)))
\f
;;;
;;; Function interface to selection/region
-;;; primative functions are defined in sunfns.c
+;;; primitive functions are defined in sunfns.c
;;;
(defun sun-yank-selection ()
"Set mark and yank the contents of the current sunwindows selection.
;; Uses the Emacs 19 terminal initialization features --- won't work with 18.
;; Rewritten for Emacs 19 by jimb, January 1992
-;; Cleaned up for new terminal package cinventions by esr, March 1993
+;; Cleaned up for new terminal package conventions by esr, March 1993
;; Should work well for Televideo TVI 925 although it's overkill.
;;
;; The Wyse50 is ergonomically wonderful, but its escape-sequence design sucks
(defun te-more-break-flush-pending-output ()
"Discard any output which has been received by the terminal emulator but
-not yet proceesed and then proceed from the more break."
+not yet processed and then proceed from the more break."
(interactive)
(te-more-break-unwind)
(te-flush-pending-output))
(put 'terminal-mode 'mode-class 'special)
;; This is only separated out from function terminal-emulator
-;; to keep the latter a little more managable.
+;; to keep the latter a little more manageable.
(defun terminal-mode ()
- "Set up variables for use f the terminal-emualtor.
+ "Set up variables for use with the terminal-emulator.
One should not call this -- it is an internal function
of the terminal-emulator"
(kill-all-local-variables)
;;; M-C-e end-of-bibtex-entry
;;; Mike Newton (newton@gumby.cs.caltech.edu) 90.11.17
;;; * Handle items like
-;;; title = poft # "Fifth Tri-quaterly" # random-conf,
+;;; title = poft # "Fifth Tri-quarterly" # random-conf,
;;; and title = {This title is inside curlies}
;;; * added user settable, always present, optional fields
;;; * fixed 'bibtex-find-it's doc string's location
-;;; * bibtex-field-text made more general (it wouldnt handle the # construct)
+;;; * bibtex-field-text made more general (it wouldn't handle the # construct)
;;; and it now handles a small subset of the {} cases
;;; Bengt Martensson, March 6
Equal to the space needed for the longest name part.")
(defun bibtex-current-entry-label (&optional include-cite kill)
- "Return the label of the bibtex entry containing, or preceeding point.
+ "Return the label of the bibtex entry containing, or preceding point.
Optional argument INCLUDE-CITE, if true means put a '\\cite{}' around the
returned value. Second optional argument KILL, if true, means place the
returned value in the kill buffer. Interactively; providing prefix
The intention is that someone will write a function that can be bound to
a mouse key so that people entering TeX can just mouse on the bibtex entry
and have the citation key inserted at the current point (which will almost
-certainly be in some other bufer). In the interim this function is
+certainly be in some other buffer). In the interim this function is
marginally useful for keyboard binding and is not bound by default.
Suggested binding is ^C-k."
(interactive (list current-prefix-arg t))
(setq local-abbrev-table bibtex-mode-abbrev-table)
(make-local-variable 'paragraph-start)
(setq paragraph-start "^[ \f\n\t]*$")
- (auto-fill-mode 1) ; nice alignements
+ (auto-fill-mode 1) ; nice alignments
(setq left-margin (+ bibtex-text-alignment 1))
(run-hooks 'bibtex-mode-hook))
Bugs:
1. Text between the closing brace ending one bibtex entry, and the @ starting
- the next, is considered part of the PRECEEDING entry. Perhaps it should be
+ the next, is considered part of the PRECEDING entry. Perhaps it should be
part of the following entry."
(interactive)
(save-restriction
(end-of-bibtex-entry)
(point)))
(sort-subr nil ; reversep
- ;; begining of record function
+ ;; beginning of record function
'forward-line
;; end of record function
(function (lambda () (and (re-search-forward "}\\s-*\n[\n \t]*@" nil 'move)
(defun kill-ispell ()
"Kill the ispell process.
-Any changes the your private dictionay
+Any changes in your private dictionary
that have not already been dumped will be lost."
(interactive)
(if ispell-process
:file FILENAME scan the named file, and print the file offsets of
any misspelled words
-:insert WORD put word in private dictonary
+:insert WORD put word in private dictionary
:accept WORD don't complain about word any more this session
some words in the dictionary, they are offered as near misses.
r Replace. Replace the word with a string you type. Each word
of your new string is also checked.
-i Insert. Insert this word in your private dictonary (kept in
+i Insert. Insert this word in your private dictionary (kept in
`$HOME/ispell.words').
a Accept. Accept this word for the rest of this editing session,
- but don't put it in your private dictonary.
+ but don't put it in your private dictionary.
l Lookup. Look for a word in the dictionary by fast binary
search, or search for a regular expression in the dictionary
using grep.
;;; `pages-directory-address-mode' now sets local variables and enables
;;; `describe-mode' to describe Addresses Directory mode.
;;;
-;;; `pages-directory-for-addresses' now sets the buffer-modifed flag
+;;; `pages-directory-for-addresses' now sets the buffer-modified flag
;;; for the Addresses Directory to nil.
;;;
;;; The documentation string for both `pages-directory-mode' and
; Washington, DC 20515
;
; Congressional committee concerned with permitting or preventing
-; monopolistic restictions on the use of software technology
+; monopolistic restrictions on the use of software technology
;
; \f
; George Lakoff
(delete-char -1)
(indent-to col)
(move-to-column column))))
- ;; This call will go away when Emacs gets real horizonal autoscrolling
+ ;; This call will go away when Emacs gets real horizontal autoscrolling
(hscroll-point-visible)))
\f
(interactive "P")
(if arg (forward-line (1- (prefix-numeric-value arg))))
(beginning-of-line)
- ;; This call will go away when Emacs gets real horizonal autoscrolling
+ ;; This call will go away when Emacs gets real horizontal autoscrolling
(hscroll-point-visible))
(defun picture-end-of-line (&optional arg)
(if arg (forward-line (1- (prefix-numeric-value arg))))
(beginning-of-line)
(skip-chars-backward " \t" (prog1 (point) (end-of-line)))
- ;; This call will go away when Emacs gets real horizonal autoscrolling
+ ;; This call will go away when Emacs gets real horizontal autoscrolling
(hscroll-point-visible))
(defun picture-forward-column (arg)
(end-of-line)
(if (eobp) (newline) (forward-char 1))
(setq arg (1- arg))))
- ;; This call will go away when Emacs gets real horizonal autoscrolling
+ ;; This call will go away when Emacs gets real horizontal autoscrolling
(hscroll-point-visible))
(defun picture-open-line (arg)
(save-excursion
(end-of-line)
(open-line arg))
- ;; This call will go away when Emacs gets real horizonal autoscrolling
+ ;; This call will go away when Emacs gets real horizontal autoscrolling
(hscroll-point-visible))
(defun picture-duplicate-line ()
;;; Commentary:
-;; This mode orovides an Emacs interface to the UNIX spell(1) program.
+;; This mode provides an Emacs interface to the UNIX spell(1) program.
;; Entry points are `spell-buffer', `spell-word', `spell-region' and
;; `spell-string'. These facilities are documented in the Emacs user's
;; manual.
(or (tex-validate-region (point) end)
(progn
(push-mark (point))
- (message "Mismatch found in pararaph starting here")
+ (message "Mismatch found in paragraph starting here")
(sit-for 4)))))
(goto-char opoint))))
\f
; 19 October 1990
-; @setfilename modifed to work with include files; see @include
+; @setfilename modified to work with include files; see @include
; (defun texinfo-format-setfilename ()
; (let ((arg (texinfo-parse-arg-discard)))
; (setq texinfo-format-filename
;; In the original version, include files were ignored by Info but
;; incorporated in to the printed manual. To make references to the
;; included file, the Texinfo source file has to refer to the included
-;; files using the `(filename)nodename' format for refering to other
+;; files using the `(filename)nodename' format for referring to other
;; Info files. Also, the included files had to be formatted on their
;; own. It was just like they were another file.
menus) before it constructs the master menu.
The function removes the detailed part of an already existing master
-menu. This action depends on the pre-exisitng master menu using the
+menu. This action depends on the pre-existing master menu using the
standard `texinfo-master-menu-header'.
The master menu has the following format, which is adapted from the
(if indented-text-mode-map
()
- ;; Make different definintion for TAB before the one in text-mode-map, but
+ ;; Make different definition for TAB before the one in text-mode-map, but
;; share the rest.
(let ((newmap (make-sparse-keymap)))
(define-key newmap "\t" 'indent-relative)
;;; Commentary:
;; This package gives you the capability to run Emacs Lisp commands at
-;; specified simes in the future, either as one-shots or periodically.
+;; specified times in the future, either as one-shots or periodically.
;; The single entry point is `run-at-time'.
;;; Code:
{ if (!NULL_INTERVAL_P (i)) mark_interval_tree (i); }
/* The oddity in the call to XUNMARK is necessary because XUNMARK
- expands to an assigment to its argument, and most C compilers don't
+ expands to an assignment to its argument, and most C compilers don't
support casts on the left operand of `='. */
#define UNMARK_BALANCE_INTERVALS(i) \
{ \
If the object referred to has not been seen yet, recursively mark
all the references contained in it.
- If the object referenced is a short string, the referrencing slot
+ If the object referenced is a short string, the referencing slot
is threaded into a chain of such slots, pointed to from
the `size' field of the string. The actual string size
lives in the last slot in the chain. We recognize the end
\f
DEFUN ("overlays-at", Foverlays_at, Soverlays_at, 1, 1, 0,
- "Return a list of the overays that contain position POS.")
+ "Return a list of the overlays that contain position POS.")
(pos)
Lisp_Object pos;
{
Fbarf_if_buffer_read_only ();
/* Inserting a newline at the end of a line produces better
- redisplay in try_window_id than inserting at the ebginning fo a
+ redisplay in try_window_id than inserting at the beginning of a
line, and the textual result is the same. So, if we're at
beginning of line, pretend to be at the end of the previous line.
programs assume that if you have a config.h file, you must declare
the type of getenv.
- This declaration shouldn't appear when alloca.s or ymakfile
+ This declaration shouldn't appear when alloca.s or ymakefile
includes config.h. */
#ifndef NOT_C_CODE
extern char *getenv ();
indirect_function (object)
register Lisp_Object object;
{
- Lisp_Object tortise, hare;
+ Lisp_Object tortoise, hare;
- hare = tortise = object;
+ hare = tortoise = object;
for (;;)
{
break;
hare = XSYMBOL (hare)->function;
- tortise = XSYMBOL (tortise)->function;
+ tortoise = XSYMBOL (tortoise)->function;
- if (EQ (hare, tortise))
+ if (EQ (hare, tortoise))
Fsignal (Qcyclic_function_indirection, Fcons (object, Qnil));
}
filemodestring (&s, modes);
values[8] = make_string (modes, 10);
#ifdef BSD4_3 /* Gross kludge to avoid lack of "#if defined(...)" in VMS */
-#define BSD4_2 /* A new meaning to the term `backwards compatability' */
+#define BSD4_2 /* A new meaning to the term `backwards compatibility' */
#endif
#ifdef BSD4_2 /* file gid will be dir gid */
dirname = Ffile_name_directory (filename);
exist inside frame objects lives in the following structure instead.
NOTE: the_only_frame is not checked for garbage collection; don't
- store collectable objects in any of its fields!
+ store collectible objects in any of its fields!
You're not/The only frame in town/... */
/* Return a Lisp_String containing the text of the current buffer from
START to END. If text properties are in use and the current buffer
- has properties in the range specifed, the resulting string will also
+ has properties in the range specified, the resulting string will also
have them.
We don't want to use plain old make_string here, because it calls
else if (XTYPE (args[n]) == Lisp_Int && *format != 's')
{
#ifdef LISP_FLOAT_TYPE
- /* The following loop issumes the Lisp type indicates
+ /* The following loop assumes the Lisp type indicates
the proper way to pass the argument.
So make sure we have a flonum if the argument should
be a double. */
if ((XTYPE (arg1) == Lisp_Int) && /* common lisp spec */
(XTYPE (arg2) == Lisp_Int)) /* don't promote, if both are ints */
{ /* this can be improved by pre-calculating */
- int acc, x, y; /* some binary powers of x then acumulating */
- /* these, therby saving some time. -wsr */
+ int acc, x, y; /* some binary powers of x then accumulating */
+ /* these, thereby saving some time. -wsr */
x = XINT (arg1);
y = XINT (arg2);
acc = 1;
\f
DEFUN ("select-frame", Fselect_frame, Sselect_frame, 1, 2, "e",
"Select the frame FRAME.\n\
-Subseqent editing commands apply to its selected window.\n\
+Subsequent editing commands apply to its selected window.\n\
The selection of FRAME lasts until the next time the user does\n\
something to select a different frame, or until the next time this\n\
function is called.")
choose_minibuf_frame ();
/* We want to make sure that the next event generates a frame-switch
- event to the appropriate frame. This seems kludgey to me, but
+ event to the appropriate frame. This seems kludgy to me, but
before you take it out, make sure that evaluating something like
(select-window (frame-root-window (new-frame))) doesn't end up
with your typing being interpreted in the new frame instead of
/* Name of this frame: a Lisp string. See also `explicit_name'. */
Lisp_Object name;
- /* The frame which should recieve keystrokes that occur in this
+ /* The frame which should receive keystrokes that occur in this
frame, or nil if they should go to the frame itself. This is
usually nil, but if the frame is minibufferless, we can use this
to redirect keystrokes to a surrogate minibuffer frame when
/* 2. places fildes into raw mode */
/* 3. converts ioctl arguments to datastream */
/* 4. waits for 2 secs for acknowledgement before */
-/* timimg out. */
+/* timing out. */
/* 5. places response in callers buffer ( just like */
/* ioctl. */
/* 6. returns fildes to its original mode */
Vafter_change_function = value;
}
-/* Signal a change to the buffer immediatly before it happens.
+/* Signal a change to the buffer immediately before it happens.
START and END are the bounds of the text to be changed,
as Lisp objects. */
}
}
-/* Signal a change immediatly after it happens.
+/* Signal a change immediately after it happens.
POS is the address of the start of the changed text.
LENDEL is the number of characters of the text before the change.
(Not the whole buffer; just the part that was changed.)
/* Never reach here */
}
-/* Effect the adjustments neccessary to the interval tree of BUFFER
+/* Effect the adjustments necessary to the interval tree of BUFFER
to correspond to the deletion of LENGTH characters from that buffer
text. The deletion is effected at position START (relative to the
buffer). */
}
}
\f
-/* Make the adjustments neccessary to the interval tree of BUFFER to
+/* Make the adjustments necessary to the interval tree of BUFFER to
represent an addition or deletion of LENGTH characters starting
at position START. Addition or deletion is indicated by the sign
of LENGTH. */
had its appropriate sticky property set (front_sticky, rear_sticky),
the new text has only its properties. If one of the sticky properties
is set, then the new text "sticks" to that region and its properties
- depend on merging as above. If both the preceding and succeding
+ depend on merging as above. If both the preceding and succeeding
intervals to the new text are "sticky", then the new text retains
only its properties, as if neither sticky property were set. Perhaps
we should consider merging all three sets of properties onto the new
Vdeactivate_mark = Qnil;
/* If minibuffer on and echo area in use,
- wait 2 sec and redraw minibufer. */
+ wait 2 sec and redraw minibuffer. */
if (minibuf_level && echo_area_glyphs)
{
/* Number of seconds between polling for input. */
int polling_period;
-/* Nonzero means polling for input is temporarily suppresed. */
+/* Nonzero means polling for input is temporarily suppressed. */
int poll_suppress_count;
#ifdef POLL_FOR_INPUT
remain unchanged.
Since this event came from a macro, it would be misleading to
- leave internal_last_event_frame set to whereever the last
+ leave internal_last_event_frame set to wherever the last
real event came from. Normally, a switch-frame event selects
internal_last_event_frame after each command is read, but
events read from a macro should never cause a new frame to be
the returned symbol.
The symbols we create are supposed to have an
- `event-symbol-elements' propery, which lists the modifiers present
+ `event-symbol-elements' property, which lists the modifiers present
in the symbol's name. */
static Lisp_Object
use save_excursion_{save,restore} here, because they
save point as well as the current buffer; we don't
want to save point, because redisplay may change it,
- to accomodate a Fset_window_start or something. We
+ to accommodate a Fset_window_start or something. We
don't want to do this at the top of the function,
because we may get input from a subprocess which
wants to change the selected window and stuff (say,
}
/* If STUFFSTRING is a string, stuff its contents as pending terminal input.
- Then in any case stuff anthing Emacs has read ahead and not used. */
+ Then in any case stuff anything Emacs has read ahead and not used. */
stuff_buffered_input (stuffstring)
Lisp_Object stuffstring;
/* Total number of times read_char has returned, outside of macros. */
extern int num_nonmacro_input_chars;
-/* Nonzero means polling for input is temporarily suppresed. */
+/* Nonzero means polling for input is temporarily suppressed. */
extern int poll_suppress_count;
/* Keymap mapping ASCII function key sequences onto their preferred forms.
structures. See, e.g., struct Lisp_String below. */
#define DECLARE_INTERVALS INTERVAL intervals;
-/* Macro used to condionally compile interval initialization into
+/* Macro used to conditionally compile interval initialization into
certain code. See, e.g., alloc.c. */
#define INITIALIZE_INTERVAL(ptr,val) ptr->intervals = val
? (sign_extend_temp | 0xFF000000) \
: (sign_extend_temp & 0x00FFFFFF))
-#ifdef emacs /* Don't do this when makeing xmakefile! */
+#ifdef emacs /* Don't do this when making xmakefile! */
extern int sign_extend_temp;
#endif
/* #define VIRT_ADDR_VARIES */
\f
-/* For University of Utah 4.3bsd implemetation on HP300s.
+/* For University of Utah 4.3bsd implementation on HP300s.
The #ifndef __GNUC__ definitions are required for the "standard" cc,
a very old, brain-dead version of PCC. */
-/* machine description file for Netional Semiconductor 32000, running Genix.
+/* machine description file for National Semiconductor 32000, running Genix.
Copyright (C) 1985, 1986 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#define EXPLICIT_SIGN_EXTEND
/* Data type of load average, as read out of kmem. */
-/* Suspect there is something wierd about this machine, so turn it off. */
+/* Suspect there is something weird about this machine, so turn it off. */
/* #define LOAD_AVE_TYPE long */
#define NO_UNION_TYPE
-/* Sun can't write competant compilers */
+/* Sun can't write competent compilers */
#define COMPILER_REGISTER_BUG
/* XINT must explicitly sign-extend */
}
#endif
\f
-/* Low level output routines for charaters and strings */
+/* Low level output routines for characters and strings */
/* Lisp functions to do output using a stream
must have the stream in a variable called printcharfun
If read_kbd is a pointer to a struct Lisp_Process, then the
function returns true iff we received input from that process
before the timeout elapsed.
- Otherwise, return true iff we recieved input from any process. */
+ Otherwise, return true iff we received input from any process. */
wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
int time_limit, microsecs;
do_display != 0 means redisplay should be done to show subprocess
output that arrives. This version of the function ignores it.
- Return true iff we recieved input from any process. */
+ Return true iff we received input from any process. */
int
wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
/* NOTES:
- Only relocate the blocs neccessary for SIZE in r_alloc_sbrk,
+ Only relocate the blocs necessary for SIZE in r_alloc_sbrk,
rather than all of them. This means allowing for a possible
hole between the first bloc and the end of malloc storage. */
from the system. */
extern POINTER (*__morecore) ();
-/* Intialize various things for memory allocation. */
+/* Initialize various things for memory allocation. */
static void
r_alloc_init ()
#define _setjmp setjmp
#define _longjmp longjmp
-/* On USG systems the system calls are interruptable by signals
+/* On USG systems the system calls are interruptible by signals
that the user program has elected to catch. Thus the system call
must be retried in these cases. To handle this without massive
changes in the source code, we remap the standard system call names
Define INTERRUPT_INPUT to make interrupt_input = 1 the default (use SIGIO)
SIGIO can be used only on systems that implement it (4.2 and 4.3).
- CBREAK mode has two disadvatages
+ CBREAK mode has two disadvantages
1) At least in 4.2, it is impossible to handle the Meta key properly.
I hear that in system V this problem does not exist.
2) Control-G causes output to be discarded.
Define INTERRUPT_INPUT to make interrupt_input = 1 the default (use SIGIO)
SIGIO can be used only on systems that implement it (4.2 and 4.3).
- CBREAK mode has two disadvatages
+ CBREAK mode has two disadvantages
1) At least in 4.2, it is impossible to handle the Meta key properly.
I hear that in system V this problem does not exist.
2) Control-G causes output to be discarded.
/* #define NONSYSTEM_DIR_LIBRARY */
/* Define this symbol if your system has the functions bcopy, etc.
- * s800 and later versions of s300 (s200) kernels have equivilents
+ * s800 and later versions of s300 (s200) kernels have equivalents
* of the BSTRING functions of BSD. If your s200 kernel doesn't have
* em comment out this section.
*/
#define _longjmp longjmp
*/
-/* On USG systems the system calls are interruptable by signals
+/* On USG systems the system calls are interruptible by signals
that the user program has elected to catch. Thus the system call
must be retried in these cases. To handle this without massive
changes in the source code, we remap the standard system call names
#define _setjmp setjmp
#define _longjmp longjmp
-/* On USG systems the system calls are interruptable by signals
+/* On USG systems the system calls are interruptible by signals
that the user program has elected to catch. Thus the system call
must be retried in these cases. To handle this without massive
changes in the source code, we remap the standard system call names
#define _setjmp setjmp
#define _longjmp longjmp
-/* On USG systems the system calls are interruptable by signals
+/* On USG systems the system calls are interruptible by signals
that the user program has elected to catch. Thus the system call
must be retried in these cases. To handle this without massive
changes in the source code, we remap the standard system call names
#define _setjmp setjmp
#define _longjmp longjmp
-/* On USG systems the system calls are interruptable by signals
+/* On USG systems the system calls are interruptible by signals
that the user program has elected to catch. Thus the system call
must be retried in these cases. To handle this without massive
changes in the source code, we remap the standard system call names
#define OSF1
-/* Define _BSD to tell the inlcude files we're running under
+/* Define _BSD to tell the include files we're running under
the BSD universe and not the SYSV universe. */
#define C_SWITCH_SYSTEM -D_BSD
Define INTERRUPT_INPUT to make interrupt_input = 1 the default (use SIGIO)
SIGIO can be used only on systems that implement it (4.2 and 4.3).
- CBREAK mode has two disadvatages
+ CBREAK mode has two disadvantages
1) At least in 4.2, it is impossible to handle the Meta key properly.
I hear that in system V this problem does not exist.
2) Control-G causes output to be discarded.
\f
/* Special hacks needed to make Emacs run on this system. */
-/* On RTU systems (like USG) the system calls are interruptable by signals
+/* On RTU systems (like USG) the system calls are interruptible by signals
that the user program has elected to catch. Thus the system call
must be retried in these cases. To handle this without massive
changes in the source code, we remap the standard system call names
#include "sunos4-0.h"
-/* 4.1.1 makes these system calls interruptable. */
+/* 4.1.1 makes these system calls interruptible. */
#define read sys_read
#define write sys_write
INTERRUPT_INPUT to decide whether to use it by default.
SIGIO can be used only on systems that implement it (4.2 and 4.3).
- CBREAK mode has two disadvatages
+ CBREAK mode has two disadvantages
1) At least in 4.2, it is impossible to handle the Meta key properly.
I hear that in system V this problem does not exist.
2) Control-G causes output to be discarded.
* Define HAVE_TERMIO if the system provides sysV-style ioctls
* for terminal control.
*
- * Do not define both. HAVE_TERMIOS is prefered, if it is
+ * Do not define both. HAVE_TERMIOS is preferred, if it is
* supported on your system.
*/
Define INTERRUPT_INPUT to make interrupt_input = 1 the default (use SIGIO)
SIGIO can be used only on systems that implement it (4.2 and 4.3).
- CBREAK mode has two disadvatages
+ CBREAK mode has two disadvantages
1) At least in 4.2, it is impossible to handle the Meta key properly.
I hear that in system V this problem does not exist.
2) Control-G causes output to be discarded.
#define _setjmp setjmp
#define _longjmp longjmp
-/* On USG systems the system calls are interruptable by signals
+/* On USG systems the system calls are interruptible by signals
that the user program has elected to catch. Thus the system call
must be retried in these cases. To handle this without massive
changes in the source code, we remap the standard system call names
#define _setjmp setjmp
#define _longjmp longjmp
-/* On USG systems the system calls are interruptable by signals
+/* On USG systems the system calls are interruptible by signals
that the user program has elected to catch. Thus the system call
must be retried in these cases. To handle this without massive
changes in the source code, we remap the standard system call names
#define _setjmp setjmp
#define _longjmp longjmp
-/* On USG systems the system calls are interruptable by signals
+/* On USG systems the system calls are interruptible by signals
that the user program has elected to catch. Thus the system call
must be retried in these cases. To handle this without massive
changes in the source code, we remap the standard system call names
#define _setjmp setjmp
#define _longjmp longjmp
-/* On USG systems the system calls are interruptable by signals
+/* On USG systems the system calls are interruptible by signals
that the user program has elected to catch. Thus the system call
must be retried in these cases. To handle this without massive
changes in the source code, we remap the standard system call names
#define _setjmp setjmp
#define _longjmp longjmp
-/* On USG systems the system calls are interruptable by signals
+/* On USG systems the system calls are interruptible by signals
that the user program has elected to catch. Thus the system call
must be retried in these cases. To handle this without massive
changes in the source code, we remap the standard system call names
Define INTERRUPT_INPUT to make interrupt_input = 1 the default (use SIGIO)
SIGIO can be used only on systems that implement it (4.2 and 4.3).
- CBREAK mode has two disadvatages
+ CBREAK mode has two disadvantages:
1) At least in 4.2, it is impossible to handle the Meta key properly.
I hear that in system V this problem does not exist.
2) Control-G causes output to be discarded.
#define _setjmp setjmp
#define _longjmp longjmp
-/* On USG systems the system calls are interruptable by signals
+/* On USG systems the system calls are interruptible by signals
that the user program has elected to catch. Thus the system call
must be retried in these cases. To handle this without massive
changes in the source code, we remap the standard system call names
while ((limit - pos) * direction >= 0)
pos += BM_tab[FETCH_CHAR(pos)];
/* now run the same tests to distinguish going off the */
- /* end, a match or a phoney match. */
+ /* end, a match or a phony match. */
if ((pos - limit) * direction <= len)
break; /* ran off the end */
/* Found what might be a match.
struct cursor DefaultCursor = {15, 0, PIX_SRC ^ PIX_DST, &ArrowCursorMpr};
#else
-/* The default left-arror cursor, with XOR drawing. */
+/* The default left-arrow cursor, with XOR drawing. */
static short ArrowCursorData[16] = {
0x8000,0xC000,0xE000,0xF000,0xF800,0xFC00,0xFE00,0xF000,
0xD800,0x9800,0x0C00,0x0C00,0x0600,0x0600,0x0300,0x0300};
return(-1);
}
/*
- * The shelltool select saves newlines as carrige returns,
+ * The shelltool select saves newlines as carriage returns,
* but emacs wants newlines.
*/
for (i = 0; i < n; i++)
}
/* If we find another earlier comment-ender,
- any comment-starts earier than that don't count
+ any comment-starts earlier than that don't count
(because they go with the earlier comment-ender). */
if (code == Sendcomment
&& SYNTAX_COMMENT_STYLE (FETCH_CHAR (from)) == comstyle)
}
/* If we find another earlier comment-ender,
- any comment-starts earier than that don't count
+ any comment-starts earlier than that don't count
(because they go with the earlier comment-ender). */
if (code == Sendcomment
&& SYNTAX_COMMENT_STYLE (FETCH_CHAR (from)) == comstyle)
s.main.c_oflag &= ~OLCUC; /* Disable map of lower case to upper on
output */
#if 0
- /* Said to be unnecesary: */
+ /* Said to be unnecessary: */
s.main.c_cc[VMIN] = 1; /* minimum number of characters to accept */
s.main.c_cc[VTIME] = 0; /* wait forever for at least 1 character */
#endif
unrequest_sigio ();
}
-#ifdef FASYNC /* F_SETFL does not imply existance of FASYNC */
+#ifdef FASYNC /* F_SETFL does not imply existence of FASYNC */
request_sigio ()
{
of the requested actions could not be performed.
We must read settings back to ensure tty setup properly.
AIX requires this to keep tty from hanging occasionally." */
- /* This make sure that we dont loop indefinetly in here. */
+ /* This make sure that we don't loop indefinitely in here. */
for (i = 0 ; i < 10 ; i++)
if (tcsetattr (fd, waitp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
{
}
#ifdef F_SETFL
-#ifdef F_GETOWN /* F_SETFL does not imply existance of F_GETOWN */
+#ifdef F_GETOWN /* F_SETFL does not imply existence of F_GETOWN */
if (interrupt_input)
{
old_fcntl_owner = fcntl (0, F_GETOWN, 0);
#endif
#ifdef F_SETFL
-#ifdef F_SETOWN /* F_SETFL does not imply existance of F_SETOWN */
+#ifdef F_SETOWN /* F_SETFL does not imply existence of F_SETOWN */
if (interrupt_input)
{
reset_sigio ();
#ifdef VMS
#ifdef LINK_CRTL_SHARE
#ifdef SHAREABLE_LIB_BUG
-/* Variables declared noshare and initialized in shareable libraries
+/* Variables declared noshare and initialized in sharable libraries
cannot be shared. The VMS linker incorrectly forces you to use a private
version which is uninitialized... If not for this "feature", we
could use the C library definition of sys_nerr and sys_errlist. */
* to names for our own functions in sysdep.c that do the system call
* with retries. Actually, for portability reasons, it is good
* programming practice, as this example shows, to limit all actual
- * system calls to a single occurance in the source. Sure, this
+ * system calls to a single occurrence in the source. Sure, this
* adds an extra level of function call overhead but it is almost
* always negligible. Fred Fish, Unisoft Systems Inc.
*/
"power-fail restart", /* 19 SIGPWR */
"window size changed", /* 20 SIGWINCH */
"undefined", /* 21 */
- "pollable event occured", /* 22 SIGPOLL */
+ "pollable event occurred", /* 22 SIGPOLL */
"sendable stop signal not from tty", /* 23 SIGSTOP */
"stop signal from tty", /* 24 SIGSTP */
"continue a stopped process", /* 25 SIGCONT */
sys_creat (va_alist)
va_dcl
{
- va_list list_incrementor;
+ va_list list_incrementer;
char *name;
int mode;
int rfd; /* related file descriptor */
extern int vms_stmlf_recfm;
va_count (count);
- va_start (list_incrementor);
- name = va_arg (list_incrementor, char *);
- mode = va_arg (list_incrementor, int);
+ va_start (list_incrementer);
+ name = va_arg (list_incrementer, char *);
+ mode = va_arg (list_incrementer, int);
if (count > 2)
- rfd = va_arg (list_incrementor, int);
- va_end (list_incrementor);
+ rfd = va_arg (list_incrementer, int);
+ va_end (list_incrementer);
if (count > 2)
{
/* Use information from the related file descriptor to set record
are renaming.
We could use the chmod function, but Eunichs uses 3 bits per user category
- to describe the protection, and VMS uses 4 (write and delete are seperate
+ to describe the protection, and VMS uses 4 (write and delete are separate
bits). To maintain portability, the VMS implementation of `chmod' wires
the W and D bits together. */
#undef ASYNC
#endif
-/* Interupt input is not used if there is no FIONREAD. */
+/* Interrupt input is not used if there is no FIONREAD. */
#ifndef FIONREAD
#undef SIGIO
#endif
#define OUTPUT_IF(a) { if (a) tputs (a, FRAME_HEIGHT (selected_frame) - curY, cmputc); }
#define OUTPUT1_IF(a) { if (a) tputs (a, 1, cmputc); }
-/* Terminal charateristics that higher levels want to look at.
+/* Terminal characteristics that higher levels want to look at.
These are all extern'd in termchar.h */
int must_write_spaces; /* Nonzero means spaces in the text
/* The uses of the "k0" capability are inconsistent; sometimes it
describes F10, whereas othertimes it describes F0 and "k;" describes F10.
- We will attempt to politely accomodate both systems by testing for
+ We will attempt to politely accommodate both systems by testing for
"k;", and if it is present, assuming that "k0" denotes F0, otherwise F10.
*/
{
-/* Flags and paramaters describing user options for handling the terminal.
+/* Flags and parameters describing user options for handling the terminal.
Copyright (C) 1985, 1986, 1990 Free Software Foundation, Inc.
This file is part of GNU Emacs.
It is assumed that for any interval plist, a property appears
only once on the list. Although some code i.e., remove_properties,
handles the more general case, the uniqueness of properties is
- neccessary for the system to remain consistent. This requirement
+ necessary for the system to remain consistent. This requirement
is enforced by the subrs installing properties onto the intervals. */
/* The rest of the file is within this conditional */
/* ****************************************************************
* mark_x
*
- * After succesfully building the new a.out, mark it executable
+ * After successfully building the new a.out, mark it executable
*/
static void
mark_x (name)
for( scns = 0; scns < f_hdr.h_nscns; scns++ ) {
- /* This is a cheesey little loop to write out the section headers
+ /* This is a cheesy little loop to write out the section headers
* in order of increasing virtual address. Dull but effective.
*/
/* ****************************************************************
* mark_x
*
- * After succesfully building the new a.out, mark it executable
+ * After successfully building the new a.out, mark it executable
*/
static
mark_x (name)
* .lib), adjust the address of where the section data is in the
* file, and write out the header.
*
- * If any section preceeds .text or .data in the file, this code
+ * If any section precedes .text or .data in the file, this code
* will not adjust the file pointer for that section correctly.
*/
/* ****************************************************************
* mark_x
*
- * After succesfully building the new a.out, mark it executable
+ * After successfully building the new a.out, mark it executable
*/
static void
mark_x (name)
/*
* mark_x
*
- * After succesfully building the new a.out, mark it executable
+ * After successfully building the new a.out, mark it executable
*/
static
mark_x (name)
/*
* mark_x
*
- * After succesfully building the new a.out, mark it executable
+ * After successfully building the new a.out, mark it executable
*/
static void
/*
- * Remeber a magic cookie so we know we've got the right binary
- * when remaping.
+ * Remember a magic cookie so we know we've got the right binary
+ * when remapping.
*/
cookie = time (0);
BLOCK_INPUT;
#ifdef HAVE_X11
- /* It's not okay to crash if the user selects a screwey cursor. */
+ /* It's not okay to crash if the user selects a screwy cursor. */
x_catch_errors ();
if (!EQ (Qnil, Vx_pointer_shape))
f->display.x = (struct x_display *) xmalloc (sizeof (struct x_display));
bzero (f->display.x, sizeof (struct x_display));
- /* Some temprorary default values for height and width. */
+ /* Some temporary default values for height and width. */
width = 80;
height = 40;
f->display.x->left_pos = -1;
}
}
-/* Erase the top horzontal lines of the contour, and then extend
+/* Erase the top horizontal lines of the contour, and then extend
the contour upwards. */
static void
XSetSelectionOwner (display, selection_atom, None, timestamp);
UNBLOCK_INPUT;
- /* It doesn't seem to be guarenteed that a SelectionClear event will be
+ /* It doesn't seem to be guaranteed that a SelectionClear event will be
generated for a window which owns the selection when that window sets
the selection owner to None. The NCD server does, the MIT Sun4 server
doesn't. So we synthesize one; this means we might get two, but
/* Invert the middle quarter of the frame for .15 sec. */
/* We use the select system call to do the waiting, so we have to make sure
- it's avaliable. If it isn't, we just won't do visual bells. */
+ it's available. If it isn't, we just won't do visual bells. */
#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
/* Subtract the `struct timeval' values X and Y,
/* The focus has changed. Update the frames as necessary to reflect
the new situation. Note that we can't change the selected frame
here, because the lisp code we are interrupting might become confused.
- Each event gets marked with the frame in which it occured, so the
+ Each event gets marked with the frame in which it occurred, so the
lisp code can tell when the switch took place by examining the events. */
static void
/* The scroll bar in which the last X motion event occurred.
- If the last X motion event occured in a scroll bar, we set this
+ If the last X motion event occurred in a scroll bar, we set this
so XTmouse_position can know whether to report a scroll bar motion or
an ordinary motion.
UNBLOCK_INPUT;
}
-/* Move a scroll bar around on the screen, to accomodate changing
+/* Move a scroll bar around on the screen, to accommodate changing
window configurations. */
static void
x_scroll_bar_move (bar, top, left, width, height)
/* Same deal here as the other #if 0. */
#if 0
- /* Clicks on the handle are always reported as occuring at the top of
+ /* Clicks on the handle are always reported as occurring at the top of
the handle. */
if (emacs_event->part == scroll_bar_handle)
emacs_event->x = bar->start;
DefaultScreen (x_current_display)))
{
UNBLOCK_INPUT_RESIGNAL;
- error ("can't notify window manager of window withdrawl");
+ error ("can't notify window manager of window withdrawal");
}
#else /* ! defined (HAVE_X11R4) */
(used when relating to the rest of the screen) and inside width
(used when sizing and drawing the scroll bar window itself).
- The handle moves up and down/back and forth in a rectange inset
+ The handle moves up and down/back and forth in a rectangle inset
from the edges of the scroll bar. These are widths by which we
inset the handle boundaries from the scroll bar edges. */
#define VERTICAL_SCROLL_BAR_LEFT_BORDER (2)
projects / emacs.git / commitdiff